Until recently, Java reminded me of the talented kid in school who keeps getting C's and B's instead of A's. "He's bright," the teacher says, "but he's not working up to his potential." So far, most Java developers have used this brilliant language in a tactical rather than strategic way. Java has enabled faster, easier, more flexible programming to develop traditionally structured applications within a conventional systems model.
The bright kid, though, will soon be earning straight A's as developers and IT managers reach beyond Java's role as a development tool to discover its far greater value as a strategic asset.
Without a doubt, the truly exhilarating promise of Java lies in dynamically structured applications deployed within a distributed systems model. Picture a world in which you can swiftly build distributed apps by reusing components, no matter what operating environment they were created for. Imagine calling objects on remote machines without regard to conflicting ORB standards. Contemplate building incredibly cool, distributed applications that deliver advanced functionality by commanding an army of mobile autonomous agents - smart objects that zip around the enterprise network fulfilling business missions on their own. Imagine chopping maintenance chores down to size by extending objects' behavior without having to rummage through their source code - in fact, without even needing it. And think about making this process so simple that many end users can perform their own basic maintenance, making the enterprise more nimble, and freeing your IT team to focus on strategically important business application development and systems design.
These are the hallmarks of a dynamic distributed environment, one that is built more readily, packed with more advanced capabilities and modified with stunning speed to keep pace with ever-changing technologies and business needs.
How long will it be before you can really do all this with Java? Next year? Three years? Five? Remarkably, Java users can accomplish it all today.
A powerful new class of Java facilities, already commercially available, renders the entire vision a reality. These facilities create a layered infrastructure, a platform that leverages Java's unprecedented and underutilized ability to manipulate objects dynamically at runtime.
Many Fortune 500 companies have quietly begun constructing enterprise-scale, distributed Java solutions based on this dynamic platform - ObjectSpace Voyager. Using Voyager, they expect to shorten the application-development cycle, reduce development costs, make development teams more productive and give end users more advanced capabilities with which to conduct business.
They are also reducing the time-to-change, making the enterprise more competitive by modifying system behavior as quickly as business needs change, on the fly - a crucial strategic advantage.
That's not all. Some observers see IT careening toward another Y2K-like fiasco because many Java applets and applications are being written with a mix of business logic and application logic - precisely the programming sin that brought us the Y2K crisis itself. After all, 750,000 developers know Java; that number will soon breeze past the million mark. The sheer volume of Java development, combined with today's competitive pressures and deadlines, virtually assures that business logic is being hard-coded into some Java applets and applications. As we all know, that will stretch out the time-to-change. Someone, sometime, will have to locate each bit of buried business logic, unzip the source and change the code - unless a dynamic infrastructure is in place. With Voyager, for example, a component's behavior can be readily extended at runtime, even if the source code isn't available.
Similarly, distributed systems development has long been hindered by the struggle for supremacy among CORBA, RMI and DCOM, the leading ORB standards, all of which are incompatible. This recalls the earliest days of telephone: you couldn't place a call to the folks next door if they subscribed to a competing service.
The dynamic Java paradigm renders this problem as obsolete as a hand-cranked telephone. How? By enabling objects to interoperate with all three ORB standards simultaneously at runtime. Again, source code is never touched.
There are other benefits, too numerous to mention here. But one thing is certain: with the advent of a dynamic, distributed platform, Java is finally ready to earn straight A's - today.
About the Author
David Norris is the president, CEO and cofounder of ObjectSpace. Prior to its start in 1992, he worked extensively as an international software consultant, building distributed solutions for large corporations. David holds a bachelor's degree in computer science from the University of Texas. To contact him visit www.objectspace.com.