CTMs require that business objects adhere to the server-side component model implemented by the vendor. A good component model is critical to the success of a development project because it defines how easily an application developer can write business objects for the CTM. The component model is a contract that defines the responsibilities of the CTM and the business objects. With a good component model, a developer knows what to expect from the CTM and the CTM understands how to manage the business object. Server-side component models are great at describing the responsibilities of the application developer and CTM vendor.
Server-side component models are based on a specification. As long as the component adheres to the specification, it can be used by the CTM. The relationship between the server-side component and the CTM is like the relationship between a CD-ROM and a CD player. As long as the component (CD-ROM) adheres to the player’s specifications, you can play it.
A CTM’s relationship with its component model is also similar to the relationship the railway system has with trains. The railway system manages the train’s environment, providing alternate routes for load balancing, multiple tracks for concurrency, and a traffic control system for managing resources. The railway provides the infrastructure that trains run on. Similarly, a CTM provides server-side components with the entire infrastructure needed to support concurrency, transactions, load balancing, etc.
Trains on the railway are like server-side components: they all perform different tasks but they do so using the same basic design. The train, like a server-side component, focuses on performing a task, such as moving cars, not managing the environment. For the engineer, the person driving the train, the interface for controlling the train is fairly simple: a brake and throttle. For the application developer, the interface to the server-side component is similarly limited.
Different CTMs may implement different component models, just as different railways have different kinds of trains. The differences between the component models vary, like railway systems having different track widths and different controls, but the fundamental operations of CTMs are the same. They all ensure that business objects are managed so that they can support large populations of users in mission-critical situations. This means that resources, concurrency, transactions, security, persistence, load balancing, and distribution of objects can be handled automatically, limiting the application developer to a simple interface. This allows the application developer to focus on the business logic instead of the enterprise infrastructure.
Microsoft was one of the first vendors to ship a CTM, the Microsoft Transaction Server (MTS). MTS uses a server-side component model and a distributed component service based on DCOM. When MTS was introduced in 1996, it was exciting because it provided a very comprehensive environment for business objects. With MTS, application developers can write COM (Common Object Model) components without worrying about system-level concerns. Once a business object is designed to conform to the COM model, MTS will take care of everything else, including transaction management, concurrency, resource management—everything! MTS makes it simple for application developers. If they want to influence how a business object interacts with system-level services, they use property sheets. It’s like setting properties of a GUI widget in Visual Basic: just bring up the property sheet and choose the transactional context, the security attributes, the name binding, and other properties from a list box or from some other GUI widget. Once the business objects are deployed in MTS, their remote interfaces can be assembled like building blocks into business solutions.
Although the features provided by MTS are great and its application developer API is very simple, as an open standard, MTS falls short. MTS is Microsoft’s proprietary CTM, which means that using it binds you to the Microsoft platform. This may not be so bad, because MTS and DCOM work well, and the Microsoft platform is pervasive. If, however, your company is expected to deploy on a non-Microsoft platform or to non-Microsoft clients, MTS is not a viable solution. In addition, MTS only supports stateless components; it doesn’t support persistent objects. Although stateless components can offer higher performance, business systems need the kind of flexibility offered by CTMs that include stateful and persistent components.
Until the fall of 1997, non-Microsoft CTMs were pretty much nonexistent. Promising products from IBM, BEA, and Hitachi were on the drawing board, while MTS was already on the market. Although the non-MTS designs were only designs, they all had one thing in common: they all used CORBA as a distributed object service.
Most non-Microsoft CTMs were focused on the more open standard of CORBA so that they could be deployed on non-Microsoft platforms and support non-Microsoft clients. CORBA is both language and platform independent, so CORBA CTM vendors could provide their customers with more implementation options. The problem with CORBA CTM designs was that they all had different server-side component models. In other words, if you developed a component for one vendor’s CTM, you couldn’t turn around and use that same component in another vendor’s CTM. The component models were too different.
With Microsoft’s MTS far in the lead (it had already been around a year), CORBA-based CTM vendors needed a competitive advantage. One problem CTMs faced was a fragmented CORBA market where each vendor’s product was different from the next. A fragmented market wouldn’t benefit anyone, so the CORBA CTM vendors needed a standard to rally around. Besides the CORBA protocol, the most obvious standard needed was a component model, which would allow clients and third-party vendors to develop their business objects to one specification that would work in any CORBA CTM. Microsoft was, of course, pushing their component model as a standard—which was attractive because MTS was an actual working product—but Microsoft didn’t support CORBA. The OMG (Object Management Group), the same people who developed the CORBA standard, were defining a server-side component model. This held promise because it was sure to be tailored to CORBA, but the OMG was slow in developing a standard—at least too slow for the evolving CTM market.
In 1997, Sun Microsystems was developing the most promising standard for server-side components called Enterprise JavaBeans. Sun offered some key advantages. First, Sun was respected and was known for working with vendors to define the best solutions possible. Sun had a habit of adopting the best ideas in the industry and then making the Java implementation an open standard—usually successfully. The Java database connectivity API, called JDBC, was a perfect example. Based largely on Microsoft’s own ODBC, JDBC offered vendors a more flexible model for plugging in their own database access drivers. In addition, developers found the JDBC API much easier to work with. Sun was doing the same thing in its newer technologies like the JavaMail™ API and the Java Naming and Directory Interface ( JNDI). These technologies were still being defined, but the collaboration among vendors was encouraging and the openness of the APIs was attractive.Although CORBA offered an open standard, it attempted to standardize very low-level facilities like security and transactions. Vendors could not justify rewriting existing products such as TUXEDO and CICS to the CORBA standards. EJB got around that problem by saying it doesn’t matter how you implement the low-level services; all that matters is all the facilities be applied to the components according to the specification—a much more palatable solution for existing and prospective CTM vendors. In addition, the Java language offered some pretty enticing advantages, not all of them purely technical. First, Java was a hot and sexy technology and simply making your product Java-compatible seemed to boost your exposure in the market. Java also offered some very attractive technical benefits. Java was more or less platform independent. A component model defined in the Java language would have definite marketing and technical benefits.
As it turned out, Sun had not been idle after it announced Enterprise JavaBeans. Sun’s engineers had been working with several leading vendors to define a flexible and open standard to which vendors could easily adapt their existing products. This was a tall order because vendors had different kinds of servers including web servers, database servers, relational database servers, application servers, and early CTMs. It’s likely that no one wanted to sacrifice their architecture for the common good, but eventually the vendors agreed on a model that was flexible enough to accommodate different implementations yet solid enough to support real mission-critical development. In December of 1997, Sun Microsystems released the first draft specification of Enterprise JavaBeans and vendors have been flocking to the server-side component model ever since.
So what does it mean to be a standard server-side component model? Quite simply, it means that you can develop business objects using the Enterprise JavaBeans (EJB) component model and expect them to work in any CTM that supports the complete EJB specification. This is a pretty powerful statement because it largely eliminates the biggest problem faced by potential customers of CORBA-based CTM products: fear of vendor “lock-in.” With a standard server-side component model, customers can commit to using an EJB-compliant CTM with the knowledge that they can migrate to a better CTM if one becomes available. Obviously, care must be taken when using proprietary extensions developed by vendors, but this is nothing new. Even in relational database industry—which has been using the SQL standard for a couple of decades—optional proprietary extensions abound.
Having a standard server-side component model has benefits beyond implementation independence. A standard component model provides a vehicle for growth in the third-party products. If numerous vendors support EJB, then creating add-on products and component libraries is more attractive to software vendors. The IT industry has seen this type of cottage industry grow up around other standards like SQL, where hundreds of add-on products can be purchased to enhance business systems whose data is stored in SQL-compliant relational databases. Report generating tools and data warehouse products are typical examples. The GUI component industry has seen the growth of its own third-party products. A healthy market for component libraries already exists for GUI component models like Microsoft’s ActiveX and Sun’s original JavaBeans component models.
Similarly, Enterprise JavaBeans will benefit from third-party products. It is likely that ERP systems and business object frameworks based on EJB will thrive. As an example, IBM’s San Francisco business object framework is migrating to the EJB component model. We will also see cottage industries grow up around EJB. Add-on products that provide services to EJB-compliant systems like credit card processing, legacy database access, and other business services will be introduced. These types of products will make development of EJB systems simpler and faster than the alternatives, making the EJB component model attractive to corporate IS and server vendors alike. It is also likely that a small market for prepackaged EJB components will also develop.