December 13, 1999
|
Printer ready |
Be prepared to manage your distributed components, or they'll manage you
| Related links: |
|
|
| And from our sister publications: |
|
|
ometimes it's easy to miss the good old days of mainframes. The centralization of IT offers definite advantages in the management and administration of computing resources. Not the least of these is the ability to have a monolithic program running in its own execution space in memory while relying on other servers only for processing input/output requests. This scenario has compelling advantages in terms of security, reliability, and, in many ways, scalability.The advent of the PC in the mid-1980s and the subsequent birth of client-server computing fundamentally changed this model of IT, and it has not been the same since. The arrival of widespread graphical interfaces on PCs and Unix workstations brought with it a developer preference for C++ and other object-oriented programming languages, such that the disaggregation of the centralized model began to occur at the program-design and enterprise-architecture levels.
Infusing the Web into the heart of business computing has accelerated the transition away from centralized IT models and toward distributed architectures to the point that the management of components and widely dispersed computing resources is critical to the success of many companies.
On the desktop, PCs and Unix workstations began the trend by letting computing happen off the host system. At the time, the incursion of the PC was mostly a hardware- and application-management headache. IT managers had to support disparate platforms and create policies that determined how the PC should fit into the business environment. Applications, whether they ran on a PC or a mainframe, were mainly procedural and monolithic.
In the early 1990s, however, C++ became popular, due in no small part to the enthusiasm and support of the language by Borland (now Inprise Corp.) and, subsequently, Microsoft. The promise of C++ was code reuse. Developers could write programs as components that could then be assembled into applications. Properly designed components could be reused by many programmers, saving significant coding time to the development shop as a whole. Unfortunately, this promise went largely unrealized.
"The promised reuse of C++ and object-oriented programming was way overblown," says Norton Greenfeld, a programming-industry analyst at research company Implements. "It turned out that [object-oriented programming] is great for some things, but programming objects for later reuse is extremely difficult and time-consuming. This explains the lack of any real market for C++ components." What made C++ so popular, however, was its suitability for writing programs that had graphical interfaces. Windows, and to a lesser extent the Unix graphical interface Motif, provided a great deal of impetus for developing in C++.
The movement from C++ to Java held a lot of promise for developers, but Java has yet to achieve the dream its creators anticipated for it. Java is an object-oriented language and an execution environment in many ways akin to an operating system. The execution environment, called the Java Virtual Machine, was supposed to run Java programs the same way on all platforms so they could be run, unmodified, on any client device. This dream has not come true, however, and programs can run differently on different clients. An additional factor is that Sun Microsystems, the parent of Java, has released numerous versions of the programming language in comparatively close succession. The result is that unless a user's Java Virtual Machine is updated regularly, new programs might not execute properly.
Andrew Watson, VP and technical director of the Object Management Group, a Framingham, Mass., consortium of vendors concerned with standards in distributed computing, says "very few real-world distributed applications rely on downloading code to the desktop, whether in Java or Microsoft's ActiveX format, because it's too hard to write code that runs correctly in all the subtly different desktop environments. In most distributed applications, the user-interface tier is a simple Web browser."
With the stabilization and standardization of Java, if it comes, some of these client-side management issues might begin to disappear.
continued...page 2, 3
Back to This Week's Issue
Send Us Your Feedback
Top of the Page
This Week's Issue
Free Print Subscription
SubscribeSupplemental Issue
Related Whitepapers
- Forrester Research study How Blade Servers Impact Datacenter Management and Agility
- ComputerWorld Tech Dossier: HP ProLiant DL360p & DL380p Gen8 Severs: Power, Flexibility & Serviceability
- ComputerWorld Tech Dossier HP ProLiant Gen8 Servers: Intelligent Mgmt and Greater Efficiency Throughout the LifeCycle
- Virtualizing Tier 1 Applications: A Critical Step on the Journey Toward the Private Cloud
- Meeting the Challenges of Endpoint Security
Related Reports
Related Webcasts
- Cloud or Premise Based Contact Center – Which is Right [for YOU]?
- Techniques for Next-Gen Data Protection using Next-Gen Computing
- Enhance Business Performance with Process Oriented Data Stewardship
- Future Proofing your Video Communication Strategy
- The view is better up here: breaking through barriers to Cloud











