Object technology has been delivering three main benefits to developers and the organizations for which they build applications. Developers of all types, using all sorts of tools on a broad range of projects, have consistently achieved ease of maintenance, ease of extensibility, and reuse:

•  Ease of Maintenance: Because they are modular, object applications are easier to maintain than procedural applications. There tend to be fewer dependencies between program components. The program logic can be expressed more naturally and in smaller chunks of code. Objects allow for uniform modeling techniques throughout the development life cycle. It’s generally easier to isolate problems and test program revisions.

•  Ease of Extensibility: The property of polymorphism makes object-oriented applications easy to extend. Developers can subclass existing interface definitions to add new object types. Through the use of common design patterns, existing capabilities continue to function. Integration and testing are so much simpler than with procedural applications.

•  Reuse: Reuse is the most promising benefit of object technology. Developers have been able to reuse small objects, coarsely grained components or business objects, frameworks and templates, and even entire application designs. Objects enable component models that enable developers to implement applications with much less effort.

The bottom line is that object technologies allow larger and more complex systems to be built faster, more flexibly, and more reliably.

Java

Java has many properties that make it an ideal platform for network computing. Let’s look at these in detail and do a bit of comparison with C++:

•  Java is a fully object-oriented programming language. Java is designed to look like C++, but Java is far simpler to use. Unlike C++, you cannot use Java to write non–object-oriented programs. Features such as automatic garbage collection make it easier and faster to write solid code.

•  Java comes with a large set of classes arranged in packages that you can use in your programs. As shown in Figure 3.4, there are classes for creating graphical user interfaces (awt), handling I/O, providing network support (net), accessing a database (sql), and creating reusable components (beans). Java provides a lot of high-level support for networking and distributed objects. It is easy to make your programs network-aware, and the Java Remote Method Invocation (RMI) API enables a Java program to invoke remote Java objects as if they were local.

Figure 3.4.  Components of the Java platform.

•  Java is an interpreted language. The Java Development Kit (JDK) includes a Java compiler that produces bytecodes for the Java Virtual Machine (JVM) rather than native machine code. To actually run a Java program, you use the Java Runtime Environment (JRE), either standalone or as part of a Web browser such as Netscape.

•  There are Just-in-Time compilers that boost the runtime performance, and Javasoft’s upcoming “Hot-spot” runtime compiler may make interpreted Java as fast as compiled C++.

•  The Java bytecodes are architecture-neutral, which allows portability to any system that has a Java runtime. Java also ensures that there are no implementation-dependent aspects of the language specification. This is different from C, where an int type can be 16, 32, or 64 bits, depending on the platform.

•  Java is a dynamic language because it has no link phase. Any Java class can be incrementally loaded into a running program and dynamically instantiated at any time. This provides high-performance, incremental loading of programs over a network versus plug-ins and ActiveX. You also can obtain information about a class at runtime using the Reflection API.

•  Java is a robust language. It provides built-in support for threads and makes it relatively easy and safe to build high-performance user interfaces and servers. By providing features such as strong-typing, exception handling, and extensive compile-time checking, whole classes of common programming errors are eliminated.

•  Java is secure. It assumes the presence of a network. All bytecodes are verified at runtime. Untrusted code is run inside a “sandbox,” where it has limited access to the local system resources, such as memory and disk. Java also supports digital signatures based on X.509 certificates.

CORBA

Diversity in hardware and software is a fact of life, and our networked environment is becoming more diverse—not less—as computers evolve. Today, businesses spend a large percentage of their technology budgets trying to integrate different elements of their environment into a total solution. Instead of improving their business processes, the majority of their time is spent on infrastructure.

The problem is that every transaction, messaging, database, or system service had its own proprietary API. Every application that used one of these services had to individually implement the API (see Figure 3.5). This led to a morass of nonintegrated systems.

Figure 3.5.  Applications have been hardwired to servers using proprietary APIs.

Many good attempts to solve the integration problem have been offered, including remote procedure calls (RPC), message-oriented–middleware (MOM) systems, queuing systems, and TP monitors. However, these products were not able to solve the entire problem, because they were vendor specific, language specific, platform specific, or did not offer enough flexibility.

The Common Object Request Broker Architecture (CORBA) provides an open specification with multivendor support to enable objects and components from various platforms to communicate with one another across networks. CORBA provides platform, vendor, operating system, network, language, and location transparency. It is fully object-oriented and provides for dynamic binding and typing.

The CORBA specification is produced by the Object Management Group (OMG), a consortium of over 1,000 companies, including most of the major vendors of systems and software. The OMG was formed in 1989 as a nonprofit organization to create a component-based software market by accelerating object standards.