Distributed object computing in Java has become increasingly popular as more complex products are written using a multi-tier architecture. A number of products and protocols are available for facilitating communication, and many developers have trouble deciding which ones to use in a given situation. Many of the communication methods work well together, and each has its strengths and weaknesses. In this article I'll discuss two of the most popular methods, CORBA and servlets. Both are useful for distributed computing, and they complement each other well.

Java Servlets provide a number of significant benefits to Web and application servers everywhere: The ability to write a server-side application that can run without regard to the hardware, server operating system or Web server A dramatic performance boost over CGI or interpreted script applications Increased productivity using the Java language to build such applications

Currently hard at work, the Object Management Group (OMG) is preparing for a preproduction release of the CORBA 3.0 specification before year-end. Such a release will give CORBA ORB vendors an opportunity to implement new CORBA services and identify potential problems before the final release in the first half of 1999.

The Internet is reshaping both the business and computing worlds, defining new ways in which business is done and how applications are designed and developed. The Web allows businesses to build distributed applications that enable the sharing of information around the world and both customers and employees to interact directly with business operations. Some strengths of the Web and Internet are their ability to provide uniform access to information through a consistent user interface and the capacity to allow applications to work together across multiple platforms. The standard technologies that make heterogeneous computing across a global network possible, including TCP/IP, HTTP and CGI, have fueled the rapid growth of applications on the Internet and intranets. However, as Web application functionality expands beyond static Web sites and basic data querying systems to more complex, mission-critical, enterprise Web applications, the current Web technologies become limiting factors in what can be achieved. To take full advantage of the Internet and the Web, a more robust, distributed-object, connection-based protocol needs to emerge as the standard communication protocol.

Corporate intranets are heterogeneous environments comprised of Web servers and search engines from numerous vendors. In such a disparate environment, how do you create a corporate collection of indexed documents for use by a single search facility? One method is to use a catalog or index server, such as Netscape's Compass Server or Microsoft's Index Server. These products employ robots or agents that build collections of indexed documents by crawling through your company's intranet via URLs. While this method is very effective, it requires careful planning and administration. An alternate method is to write a Java servlet that connects to several search engines, compiling the results into a single document.

Recently, a number of factors have conspired to ensure that the days of not considering or using a naming service and/or a directory service are probably numbered. The computing world has become more distributed and the resources more vast; finding these resources using naming and directory services has become pure necessity. Systems that were reasonably isolated in the past are now becoming part of large, integrated intranets, and in turn are merging or using the Internet. The upshot? A need for integrated naming and directory services.

With all the hype and press concerning Servlets lately, it seems as though this Java technology is ready to replace CGI as the preferred way to perform server-side processing on Web servers. Unfortunately for Servlets, just being better than CGI at server-side processing is no longer enough to be the de facto standard. Last year, a whole new approach to dynamic Web development turned CGI on its head. This new technology was called Active Server Pages, brought to us by our friends in Redmond. Offering true Rapid Application Development and a choice of scripting languages to use, Active Server Pages quickly dethroned CGI on IIS Servers and made developers much more productive. Recognizing this fact, Sun Microsystems has offered a new version of its Java Web Server that supports the dynamic compilation of Web pages mixed with Java code. Their current offering uses Web pages with a JHTML extension, which are compiled on the fly into Servlets. At JavaOne this year, Sun and third-party Servlet Engine providers, such as IBM and Live Software, demonstrated JavaServer Page technology as an evolutionary step from JHTML.

Object-oriented database platforms offer several benefits. The first one I think of is that I don't have to write code to handle the transformation of an object to a row in a table. The object model is the data model. Navigation from reference to reference is efficient because object access is in the OO language itself. How complicated that can get depends on your intent, your design and the OODB platform you're using. Most Java API's for OODBMS platforms are maturing quickly, and there are some interesting variations and parallels forming.

Introduction to CORBA CORBA, which stands for Common Object Request Broker Architecture, is an industry-standard developed by the Object Management Group (OMG), a consortium of more than 500 companies. CORBA is actually a specification for creating and using distributed objects. CORBA objects are different from typical programming language objects in three ways: CORBA objects can run on any platform; they can be located anywhere on the network; and they can be written in any language that has IDL mappings.

When developing Java network applications in a stable and controlled environment, it's easy to become complacent and ignore the possibility of network timeouts. After all, with the perfect client and server running over a local area network, timeouts won't occur to stall your application. But when your users run clients or servers over the Internet (an environment where networks can go down, badly written software can stall or communication sessions can deviate from the ideal path of a communications protocol), timeouts can cause problems if there isn't a mechanism to recognize and deal with it.

Scripting languages provide a powerful tool for easily gluing together components of a system. The CORBA community has recently begun work on a CORBA Component framework which incorporates many of the architectural insights of JavaBeans. This article explores how JavaScript could serve as a scripting language for such CORBA components to quickly create script applications which draw on mission critical network services.

This article proposes to reinvent select TCP based application layer Internet protocols and their client/server implementations in the framework of CORBA/IIOP [2]. Advantages of this approach will be exhibited from the perspectives of programming, deployment and protocol evolution. As an illustrative example, I will attempt a redefinition of the IRC protocol [1] in terms of OMG IDL (Interface Definition Language). I will implement its server object and client application in Java with Javasoft's JavaIDL [3] as the underlying ORB, paying attention to implementation issues different from those of its socket counterpart. I will then briefly go over various benefits the CORBA framework can bring to the deployment of the reinvented IRC 'protocol', with emphasis on the seamless incorporation of load balancing, security and transaction processing control.

While it is easier to write CORBA applications in Java than in any other language, there are still a few conceptual stumbling stones that Java/CORBA programmers need to be aware of. The combination of Java and CORBA, the OMG's middleware standard, has been receiving a lot of interest in both the Java and CORBA communities because of their apparent similarities in syntax and concepts. An OMG-defined language mapping and a number of existing commercial and public domain CORBA platforms open up the CORBA world for Java applications and components. In this article, I look at how far the integration of Java and CORBA can really go and point out a few pitfalls that arise because of subtle and not-so-subtle mismatches between the two worlds.

Component software has swept through the software industry. Millions of developers now drag and drop components on a form rather than writing source code. JavaBeansª has provided an elegant component model for the Java development environment and is widely accepted in many development environments. However, JavaBeans lacks any support for distributed computing. This article explores how CORBA and JavaBeans could work together to provide an excellent distributed component model with the added benefit of the cross language interoperability that is a trademark of CORBA. A prototype of such "CorbaBeans" is demonstrated.

Leading members of the Object Management Group are colluding to ensure the ongoing success of the Common Object Request Broker Architecture (CORBA). On May 25, 1997, the gang-of-four ... IBM, Netscape, Oracle, and SunSoft ... submitted a statement of direction to the Object Management Group to provide missing Java-like functionality to the Object Management Architecture (OMA), of which CORBA is the key component. This proposal highlights three key elements of the distributed object computing marketplace: .

Introduction Most of the available distributed systems today are based on the client/server model, which is implemented through some form of remote procedure calls, or remote objects in the case of the object-based model. The client/server paradigm however, has its own limitations. Most notably, all interactions between client and server must go through the network as shown in Figure 1.

The notion of events is quite overloaded and various event models have been suggested, standardized and implemented. In this article, I explain the event models in Java, CORBA and ORBs:

As any ex-C++ software developer will attest, the Java garbage collector greatly simplifies the task of cleaning up after your objects. With distributed software applications, the garbage collector faces many new challenges since objects may be used by applications running across the Internet. This article looks at some common solutions to garbage collection in CORBA, RMI and DCOM. Finally, the distributed garbage collector in RMI is implemented on top of CORBA.

Distributed object solutions to date have relied on pass by reference for method arguments. However, pass by value results in a much more scalable solution in some applications which manipulate numerous, fine-grained objects. This article examines how to pass by value with CORBA. Then, this implementation is used to extend the RMI on CORBA design presented in the previous issue.

RMI and CORBA are two different approaches for distributed object computing with Java. Industry experts have suggested that the two technologies are inherently incompatible with each other. In this series of columns I demonstrate how RMI could be immplemented on top of CORBA, resulting in the two technologies interoperating, and present some example applications of RMI working with CORBA. In this issue, we'll look at the differences and similarities between the two approaches.

The impact of Java on the computing world is beyond doubt; just look at the bookshelves in the computing section of any bookstore or attend any conference in the software industry. There are good reasons. The near-perfect portability of Java applications is a great boon in a multi-platform world; the ability to download Java applets and the close integration of Java with Web browsers makes it an ideal medium for Web- and Internet-based development; its ease of use compared to its most popular object-oriented predecessor, C++, makes it accessible to a much wider range of developers and speeds the development process measurably.

Two months ago (JDJ, Vol.2, Iss. 2), Ellen Siegel gave a very nice introduction to CORBA from a Java point of view. This article is focused on a more specific topic which often occurs to newcomers to the CORBA world: How do I discover the objects I want to use?

OMG's Internet Inter-ORB Protocol (IIOP) has developed quite a career in a short space of time. Its specification was released in late 1994 as part of OMG's CORBA2.0 specification. Only a few months later, the first ORBs implemented the protocol and interoperability between various ORBs was demonstrated to the world during Object World West in mid-1995. In mid-1996, Netscape declared its support for IIOP as the Internet protocol for distributed applications. Now, everyone seems to be jumping on the IIOP bandwagon. This popularity demonstrates the need for a standardised protocol for remote operation invocation.

Java has caused great excitement with its ability to animate Web pages. However, Java is a full-fledged programming language that is arguably the only language suitable for net-centric business applications. The vast majority of business applications require database access and we can expect Java applications to be no different.

Introduction Just when you thought it was safe to start learning Java, along comes yet another new technology from the those clever boffins at SunSoft, to confuse and dazzle the developer. Fortunately, it's not as complicated as it sounds. Jeeves is the name of the new Java Server API that defines a mechanism and framework for creating connection-oriented server applications. This article will take a look at what Jeeves is aiming to accomplish and why it is a much better solution to the technologies being offered today. We will conclude with a look at the time honored tradition of the Hello World' program, complete with all the source code and supporting files needed to create this masterpiece.

Introduction It's old nes that Java has taken the world by storm. Even the recently computer-illiterate are out browsing the Web, and companies are all prototyping or even deploying Web-based client software to broaden their customer base and to compete effectively in the changing marketplace. However, many of these companies happen to have large existing software bases implemented in more conventional languages such as C or C++. Furthermore, Java is a relatively new language. Many companies are not yet willing to commit to Java-based development for key mission-critical software components.

Introduction Java is particularly well suited for mobile code and distribution. However, it offers no more support for distributed computing than any other object-oriented language, such as C++ or SmallTalk.

A Capsule History of Active Webs The runaway success of the Web's HTML display language made everyone in the software community stop and take note. What was so exciting about this new technology? Was it the markup language itself? Couldn't be! HTML is just a stripped down version (DTD) of SGML, which has been around for a while. Was it the concept of a remote screen interface language? No, X terminals and the X protocol have been around for years. Could it be the HTTP protocol for transmitting HTML? Let's hope not. HTTP is basically a broken FTP, and that's been around for decades.