The primary goal of a service-oriented architecture (SOA) is to create a number of loosely coupled, reusable services. These services could then be dynamically assembled and reassembled into any number of different applications, based upon ever changing business requirements. If properly implemented, an SOA would enable an organization to develop and deploy enterprise applications much more quickly and at a lower cost than previously possible.
Mobile agents, in conjunction with a peer-to-peer based execution environment, provide a superior solution for building an SOA, when compared to currently used distributed component object models that are based upon application servers and other types of middleware.
By their very nature, mobile agents provide a set of easily reusable services. Typical examples might be the calculation of a monthly premium on an insurance policy, determining an employee's overall eligibility for health and welfare benefits, or finding a list of airline flights based on specified parameters for arrival and departure. One or more of these services could be combined to form a cohesive business process, such as binding an insurance policy, automatically making benefit selections for an employee, or booking a vacation. A set of one or more business processes would comprise an application as it is currently known today.
Inherent characteristics of mobile agents allow them to move about freely on a computer network looking for hosts with excess CPU cycles, attaching themselves to these machines, and then beginning execution. The ability of mobile agents to do their work in parallel, across a potentially large number of low cost computers, such as blade servers, provide cost savings that can not be easily realized by today's popular distributed component models. A mobile agent-based SOA easily supports the dynamic and rapid assembly of software applications which are extensible, scalable and outperform those created using today's current enterprise information architecture. Additionally, a broad number of software initiatives within one organization can all leverage the same set of agent-based services. This holds true across organizational boundaries as well, such as between business partners, governmental agencies or military branches.
An agent-based SOA provides a very easy way to reduce the initial development costs associated with a complex application. An application no longer has to be written from scratch, but rather assembled from existing off-the-shelf parts. These reusable components will be stored on a standard web server until they are needed, at which point they are downloaded into an agent execution environment. Besides lowering the cost of an initial general availability product release, these software building blocks can also help to make an application more extensible, and easier to maintain, over its useful life. Since all of the source code for any given service is cleanly encapsulated within a single mobile agent, it is much easier for a developer to find bugs and enhance existing features.
There are notable limitations in using today's leading distributed component models as a foundation for building service-oriented architectures. Taking a look at the Enterprise JavaBeans (EJB) model, the component itself is statically bound to the machine upon which it is installed. It lacks the ability to move about on a network and attach itself to an available host processor. The inability of these components to move about freely on a heterogeneous computer network directly limits this technology's ability to support the dynamic assembly of applications from a collection of available services. At the implementation level there are other key factors which limit the usefulness of EJB's as an enterprise component model. These limitations are part of the EJB specification itself.
Just as important though, the EJB, unlike a mobile agent, does not offer a single service, but rather most commonly exposes a set of very fine-grained interfaces. This approach is similar to writing traditional programming libraries and frameworks, except for the fact that the method is remotely accessible. This technical approach causes complex interdependencies to arise between EJBs. Software architects refer to these interdependencies as "surface area", with their desire being to reduce it to a minimum amount. As a result the overriding goal of creating small manageable pieces of functionality, which can be quickly and easily assembled into a robust application, is made much more difficult.
Today, a mobile agent is the closest approximation our industry has to a truly reusable software building block. As a component model it overcomes all of the limitations which were imposed on distributed Java components as a result of the EJB specification. From these loosely coupled, course grained, asynchronous services, applications will be dynamically assembled, based upon ever-changing business priorities. Systems built upon this new architecture will be far more extensible, reliable, and scaleable than traditional applications built using today's most popular distributed component models. Using an agent-based SOA in conjunction with low-cost blade servers will provide today's smart organizations with an extremely effective approach to lowering their total cost of ownership for enterprise application software.
More on this topic