For enabling application integration in e-Governance, proper selection of the architecture and a middleware to suit it is necessary, say Dr. R.Srinivasan

Application Integration is the most challenging activity today and is more so in an Enterprise like a Government. Few years ago we were talking and giving much hype to the 2-tier Client/Server architecture; but it is too inflexible and static towards the changes and dynamic needs of distributed application access/integration at an enterprise level. The proliferation of the Internet and the facilities therein has opened up the infrastructure for the 3-tier architecture that facilitates interconnection of various Application Servers to many clients through the so called "middleware", i.e. a client running in a browser will access the applications implemented on a server and the server application itself accesses a persistent storage application like a database as depicted in the figure.

It becomes imperative that in order to realise Application Integration in e-Governance, proper selection of the architecture and a middleware to suit this architecture is a must. As Dr. Thomas Mowbray says, "Software Architecture is a subset of System Architecture; software implementation is a subset of system implementation" (Ref. The Essential CORBA, System Integration Using Distributed Objects).

The software implementation, in turn, makes use of major subsystems like the various applications developed under e-Governance. In any software development project, the very first step is to have the statement/scope of the project; once the scope is well understood, we should move to the analysis part and arrive at a suitable architecture and only then application developments take place based on this architecture. Any Government going towards e-Governance should therefore start with the scope, have a thorough system study and decide the Software Architecture which has to be communicated to the application developers of the various departments (either internal developers or to the external ones to whom the job is outsourced).

Again to quote Dr. Thomas Mowbray, "About half of software development activities involve system discovery, or trying to understand the system's structure. If developers do not understand the architectural vision, then they can easily make application development and implementation choices that violate architectural assumptions". On the other hand if the applications are developed to the accepted architecture the benefits are many fold; like easy portability, application interoperability and maintainability. As mentioned in my earlier article, if the Applications themselves are developed using standard components that are designed towards the common architecture, Application Interoperability will be much easier. This should be the view of any government getting started towards software development in e-Governance.

While each government can implement governance through the Intranet, the Internet can form the backbone of all these Intranets connecting the applications of various governments together. Under this situation, it would be a preferred choice that each one of these Governments employs the same Software Architecture. In an enterprise like any of our State Government, it may be expected that more than 50% of the cost of the software system under e-Governance is incurred for operations and maintenance after the system becomes operational and about 60% of this will be due to system extensions arising out of changes in requirements. So the main characteristic of the cost-effective Software Architecture will be the flexibility and scalability. Because this architecture is going to cater to the needs across the networked enterprise, the middleware designed towards this architecture should have the characteristics namely: reliability, security, manageability, and access capability to databases.

It is said that Software Architecture design is more like an art than science. The design process is a challenging one comprising a number of heuristic steps leading towards a prototype and then perfecting it through iterative development cycle.