The introduction of Java brought several advances to the discipline of software development. Based on lessons learned from years of building software in C++, the Java language was designed to simplify the development of object-oriented, network-aware applications. It brimmed with potential and was accompanied by a wide variety of promises, including enhanced programmer productivity, seamless cross-platform deployment and an architecture for building large-scale applications.
Over the past three years, the promise of Java has been put to the test repeatedly. What has emerged is a better picture of what customers want from their software as well as what Java can and cannot do. To its credit, the design of the Java language has demonstrated tremendous programmer productivity benefits over C++. Language features such as automatic garbage collection, exception handling and inherent multi-threading support allow developers to more rapidly write high quality code. Unfortunately, Java has not delivered on some of the other promises. Despite major investment from top platform and Internet technology vendors, cross-platform execution of large applications has proven easier said than done. The sensitivity of the Java runtime to differences in underlying hardware architectures, operating systems and the virtual machines themselves has given rise to the developer cry of "write once, debug everywhere." Further, the sacrifices in performance, functionality and integration necessary to pursue portability have made it difficult to deliver compelling applications.
The high-tech industry is a very competitive environment, one based on meeting customer demand. Given a choice between two applications, if one provides more features and better integration with their present hardware and software investments, users will chose the richer, more functional one every time. In an article in the San Jose Mercury News (Feb. 9, 1998), Eric Schmidt, Sun's former Chief Technology Officer, admitted as much when he said, "The problem with client side (Java) is that many customers are satisfied with the Windows-only client." Ultimately, application adoption boils down to functionality, performance and the ability to reuse existing systems.
Where is Java Headed?
As a result of better understanding of these success factors, the market is altering its expectations as to how Java can best be used. More and more, developers are turning to the native OS to access key services in a competitive world. A recent Microsoft Developer Tracking Study showed that over 50% of Java developers use native methods. Even Java ISVs rely on native OS access for commercial development projects. Many of the top platform vendors have recognized Java's limitations and are encouraging access to native services or natively compiled executables in order to meet customer needs. As operating system technology evolves, developers who take advantage of the latest features will have an advantage.
Another recent trend is the focus on Java as a server-side technology due, in part, to the problems encountered deploying to diverse clients. With greater control over deployment targets, developers have been successful in building simple server-side applications. But building complex middle-tier logic requires access to the full range and functionality of the server's application services. It is only by taking advantage of these services that developers can create applications providing the performance, scalability, and robustness required of enterprise systems. It is interesting to note that the Enterprise JavaBeans (EJB) specification is limited in these key areas because the contributing - and fiercely competitive - vendors could not find common ground.
Turning Development Trends into Real Solutions
While the Java market has moved towards greater native access, development tools have not matched this trend. Currently, most Java tools focus on client-side applications, emphasizing cross-platform deployment over other considerations, such as performance and functionality. With these tradeoffs, applications created with today's Java environments are just not competitive against those written for the native platform using languages like Visual Basic and C++. Server-side support is also limited, as the architecture for database connectivity is immature, and there is no support for accessing the full range of platform services required by modern enterprise business systems.
Microsoft Visual J++ 6.0, Technology Preview 1, meets today's changing market needs. By combining the power of Windows and the productivity of Java, it offers the fastest way to build and deploy high-performance, data-driven client and server solutions for Windows and the Web. With Visual J++ 6.0, developers can construct powerful business applications using the Windows Foundation Classes (WFC) for Java, an object-oriented framework that encapsulates, simplifies and unifies the Win32 and Dynamic HTML programming models.
By directly accessing the Win32 API, Visual J++ 6.0 makes it possible for Java developers to produce feature-rich applications, leverage existing software investments and build powerful middle-tier business objects that integrate with a host of Windows NT application services. Moreover, through integration with the language-neutral Microsoft Component Object Model (COM), developers can build applications using "cooperating components" written in a wide variety of languages.
Visual J++ 6.0 is the first Java development tool to provide easier access to the underlying platform, and offers end-to-end solutions for developers looking to build powerful, full-featured Java applications. Other tools will soon follow, as several top Java tool vendors plan to incorporate WFC into their offerings, providing developers with even more choices and flexibility. And on other platforms, vendors will continue to expose more native functionality to Java. As the market for native Java tools grows, so too will the opportunities to build commercial quality applications, creating a wealth of new application choices for businesses and consumers.
About the Author
Bill Dunlap is the Visual J++ Technical Product Manager at Microsoft