1 Introduction to EC

Middleware is a software layer that is placed above Operating system or networking layer and below the application layer. Fundamentally, it provides services to transfer data between programs in a distributed environment hiding the details of communication protocols, OS and hardware. It also provides extended services such as data management, application services, messaging, authentication, and API management.

The role of middleware is similar to that of OS between hardware and applications. For example, when we write a C program to save application data to a file, we use stdio library functions like fopen, fprintf, and fclose. These functions call OS system calls to access the disk. Here the system calls are services provided by the OS, the stdio functions provide APIs that we used for file I/O in application programming.

The essential role of middleware is to provide an environment to manage the data exchanges in complex, heterogeneous and distributed systems. Enterprises use a variety of heterogeneous systems and applications in businesses operations. Heterogeneous systems use different technologies and run on different platforms, e.g. Java platforms, .NET platforms. The middleware technologies provide a solution to glue the systems together.

In enterprise information system development, new components are often added to the existing systems and some old components may be outdated and have to be removed. It also needs to integrate some legacy systems. Middleware plays a critical role in integrating legacy systems and newly adopted components and applications. It makes the development both economically and practically feasible.

The benefits of using middleware include:

1. Re-usability and portability: Middleware technology helps to make use of old legacy systems and application. It also helps to export and reuse newly developed components in new applications, such increases the portability of an application and improves the reliability of the system.
2. Efficient and cost effective: Middleware can help developers to build applications efficiently. It takes less time and cost to configure or develop business logic components by reusing existing components. Middleware can also help developers, architects, IT managers, and business leaders automate manual decisions. That in turn improves resource management and overall efficiency and reduce cost.
3. Seamless heterogeneous integration: Using middleware makes interaction between heterogeneous systems and application cost-effective and efficient.

EC Middleware wraps some fundamental operations in EC applications and provides them as services. The following are the three primary service modules used by EC applications.

1. Transactional Middleware (TM): Also known as Transaction Processing Monitor (TP). TM coordinates request between clients and servers. TM supports N-tier structure and load balancing. TM manages transactions over multiple databases.
2. Message-Oriented Middleware (MOM): Also known as message servers, is a middleware to provide message communication services for distributed systems. It sends messages to recipient programs that interprets these messages and takes appropriate action.
3. Object Oriented Middleware (OOM): OOM provides communication services between two components including object look-up, remote method invoking with in synchronous communication, and synchronous communication through messaging. OOM also support transactions.

The following parts and tools are commonly included in EC middleware.

1. Web servers: Web Server processes the requests and delivers it to the client. Web server uses web services that are one of the most advanced and promising way to integrate systems. Web Services works over web (or Internet) and communicate with programs via Internet protocols like Hypertext Transfer Protocol (HTTP) and Simple Mail Transfer Protocol (SMTP). It is one of the most flexible options for integration and supports both RPC and MOM systems.
2. Application servers: This is the software on which business logic components are deployed and hosted.
3. Application deployment tool: This is a middleware tool to delivery and install and un-install application components on application servers or web servers.
   
4. Enterprise service bus: This is a middleware tool used to distribute work among connected components of an application.

CORBA is a standard defined by the Object Management Group (OMG) to facilitate the communication of components that are deployed on diverse platforms. CORBA enables collaboration between systems on different operating systems, programming languages, and computing hardware. CORBA uses an object-oriented model, distributed object paradigm. CORBA is language independent, and capable of handling a variety of object life cycles. CORBA provides the foundation for component model.

DCOM was developed by Microsoft in late of 1990s to address large, complex and distributed enterprise applications. DCOM is a Microsoft proprietary technology for communication between software components on networked computers. DCOM was further evolved to COM+, which was integrated into .NET framework. This paper provides a side-by-side comparison between CORBA and DCOM (supplementary link).

EJB is Sun’s component model. EJB defines server-side components that encapsulates business logic of an applications. EJB uses Java Remote Method Invocation (RMI) for remote method call. RMI is a Java API that performs remote method invocation, the object-oriented equivalent of remote procedure calls (RPC), with support for direct transfer of serialized Java objects and distributed garbage-collection. (supplementary link).

EJB container provides a runtime environment for EJB components. It provides services for EJB component operations such as transaction, security, persistence. EJB is the core part of Java platform Enterprise Edition (Java EE).

Interoperability refers to the ability of inter-component communications between components of different component models. Components by CORBA, DCOM and EJB cannot communicate each other directly. Solving this problem, a standard web service interface is introduced, e.g. Simple Object Access Protocol (SOAP) allows one component to access another component.

We learned the concepts of PP when studying data structures and/or C programming language. In PP, we write a group of functions including the main function. Each function contains a sequence of statements. A statement may call another function. Program execution starts from the main function. We also learned **Functional programming (FP)*, a special case of PP, in which functions are pure functions, namely avoid changing state and mutable data.

We learned OOP in Java or C++ programming. Object is the subject OOP works on. In OOP, we define objects by classes. A class may define data fields (also called properties or attributes), and methods (functions or procedures in PP). An object is instanced in memory at the runtime. The execution of an OOP program starts from a main function, in which objects are instanced and object methods are invoked. A method invoking may contain another object method invoking, such that the execution of an OOP program jumps from objects to objects by method invoking.

With PP and OOP, we typically create a runnable program for an application. For example, in C programming, we write source code in C, and use compilers to convert the source code programs to an executable programs, and run them on supported processors. In Java programming, we use Java compiler to convert Java source code programs to bytecode programs, and run them on Java virtual machines.

COP is a programming paradigm to design and implement components, to build applications by combining components, and to deploy applications. COP was introduced to deal with the complexity of multi-tier enterprise applications.

COP delivers a program component, which can be loaded or installed on a middleware container or application server. The component exists as a service with given interfaces. It can be found by look-up, and its called by local and remote components.

A COP application typically contains many components connected in certain topology specified by the application. One component, serves as an entry component, where an initial service request starts by a procedure call. The procedure call invokes a procedure call of another components along the topology of the application. The data transfers between components along the topology is called the data flow the application. Usually the entry component is a client program, running on servers, desktops, or mobile devices.

COP focuses on components and deals with data objects, procedures, dependent components, interfaces, and deployment. Deployment is technology dependent, but generally, it needs packaging, configuration, package transfer and install, dependency resolving, and component instancing and dependency injection.

With COP, applications are often modeled as dependency of components. It uses component interfaces and dependency injection to reuse existing code. This is the black-box reuse model, which allows developers to use existing components without knowing its internals.

With OOP, applications are often modeled as complex hierarchies of classes, which are designed to approximate as closely as possible the business problem being solved. It reuses existing code by inheriting it from an existing base class and specializing its behavior. This form of reuse is commonly known as white-box reuse.

However, OOP are used in COP for data objects and procedures.

1. COP reduces the time and cost in application development. Using available verified in-house or third-party components to build new applications avoids reinventing the wheel, and assures the quality.
   
2. COP makes applications maintenance easy. It allows to modify a component without changing other components. A component can be updated at runtime, as long as the components aren’t currently being used. The improvements, enhancements, and fixes made to a component will immediately be available to all applications that use that component.
3. COP makes applications flexible to extend. It allows to create and deployment new components, which may dependent on existing components, but not need to change existing components.