Putting the Wraps on Legacy Code
In Frederick Brooks’ book, The Mythical Man Month, he likens the architecture of computer software to that of the great cathedrals. Built by generations of craftsmen, the cathedrals exhibit a conceptual integrity, but hide the fact that different building materials and construction techniques were used to build them. When we visit the cathedrals today, we see them as the architect had intended, and we’re not easily able to distinguish the work of one generation of builders from another.
It’s been a while since Brooks made his observation, but perhaps the idea of a software architecture is more relevant today than it was when he wrote his book at the beginning of the age of third-generation computers.
Software development is a young industry. There is no architect responsible for the guiding principles behind the design of the software that runs today. Each platform (mainframe, desktop, palm) has its own style. We’ve tried and abandoned generations of software development tools. We’ve tried to replace mainframes with client/server applications and declared the mainframe to be dead. Now, as we start the 21st century, mainframe software has just undergone perhaps the most significant rework in its history as we updated its date logic to correctly handle the century change.
If we didn’t learn anything else from Y2K, we learned that there is still a lot of mainframe software in production.
There is still time to develop a guiding architecture for this young software development field. We’re entering a new stage of computing that is perhaps the most exciting and promising of all – the age of the Internet. The Internet promises seamless computing across devices that reside in data centers on desktops, inside the cars we drive, the phones we carry and the places we live.
When Brooks wrote his book, there were thousands of computers. Today, there are millions, and before long there will be hundreds of millions. The Internet moves the power of computing from the hardware to the network. Sun Microsystems’ ad campaign, "The network is the computer," announced this reality a few years ago.
Simple Is Best
Another point Brooks makes in his book is that the simplest design is often the best, but simple solutions emerge through a process of trial and error.
One of the simple, powerful ideas of the Internet is the unique address it gives to each computing device. Large computers have no special status over small computers in TCP/IP networks. Computers exchange information across a standard protocol that includes services to handle mail, file transfers, transactions and terminal sessions. Without this simple design, there would be no Internet.
Another simple idea that finds great value on the Internet is the object model. Just as the design of a cathedral allowed craftsmen to use the best tools available while conforming to architecture, the object model allows programs to hide their internal design and code, while retaining their ability to work with other objects to form applications.
As we enter the 21st century, our challenge as software developers is to bring the value of the network to our enterprises, and to leverage the assets we’ve developed over the years into components of a ubiquitous computing environment. The road starts here, with our applications, our customers and trading partners, and our products and services.
Let’s take a closer look at the building blocks of the Internet – objects, which simplify the way programs communicate, and IP connections, which simplify the way computing devices share information.
Object-oriented programming offers a standard way to expose the interfaces of an object (how the object is described), while hiding the internals (how the object works). Inside the object lives procedural code that gives it its functionality. Once developed, these objects express business properties (for example, SKU and QtyOnHand) and methods (for example, updatePrice) that are familiar to business-oriented application developers who need not know the internals in order to build applications.
Object-oriented programming changes the way we build software, separating the internal logic from the external representation.
For many mainframe programmers, Internet development is their first exposure to objects. It might comfort a COBOL programmer to see what lives inside the objects that run on the Internet today. Look inside a COM+ object and you’re likely to find code written in C++. Look inside a Java bean, and you’ll see code written in Java.
The next step forward for legacy software will be to wrap the code that already works within objects that describe its interfaces. This will allow Internet applications to be developed by business analysts who focus on adding new business capabilities. COBOL programs will continue to run inside their object wrappers, and COBOL programmers will, in many cases, generate the object wrappers as they develop and maintain legacy applications.
Object wrappers are key to Internet-enabling our legacy systems. Instead of rewriting code that already works, software developers will use automated tools to expose the interfaces of programs that run today in CICS or other online transaction processing systems.
TCP/IP gives each device a unique address. At that address, ports provide services. For example, port 80 receives Web pages (HTTP), port 25 sends mail (SMTP) and port 21 transfers files (FTP). There are thousands of ports available at each IP address.
Here in Emeryville, Calif., the shuttle bus that takes commuters to the BART (Bay Area Rapid Transit) trains has an IP address, so we can track the bus as it makes its route. Palmtops, cell phones, cars and other mobile objects can also have IP addresses. Each of these devices will be within reach of the objects we create to represent our business.
IBM enables Internet connectivity to mainframe objects by including its TCP/IP stack with its OS/390 operating system. Now, you can reduce your computing costs by replacing SNA terminal emulators and file transfer products with newer TCP/IP versions that do not require SNA services.
To enable direct IP connections for mainframe objects, you’ll need a TCP/IP middleware product. In addition to providing the connection, this middleware invokes the mainframe program that lives inside the object, converts the data from the mainframe’s EBCDIC representation to the Internet’s ASCII format, and handles decimal alignment and other data representation translations.
With TCP/IP connections and object wrappers, your mainframe and its applications will be Internet enabled. Two recent advances in Internet technology will play a significant role in helping you build and deploy Internet applications – application servers and XML.
Internet users demand transactions with the same high level of performance and reliability as they’ve experienced on the mainframe. A new class of software called an Application Server is helping companies meet this demand.
Application servers provide a scalable platform for transactional Web applications. Java application servers work with objects (Java beans) that conform to the Enterprise Java Beans (EJB) standard. Microsoft provides similar functionality on the Windows platform with COM+. Large enterprises that will deploy Web sites on both of these platforms should select software development tools that generate runtime components for both environments from a single object.
Application servers also provide a security environment for Internet transactions. They run behind the firewall with mainframes and other servers to maintain business information. They communicate across the firewall using HTML or XML. XML will enable devices like cell phones and palm computers to interact with objects on the Internet.
XML is a markup language derived from the SGML standard. XML provides a way for an object to express itself across a network. In addition to its properties (for example, a customer name and credit rating), XML can expose the meaning of the properties (for example, a list of valid credit ratings), so a connected device can quickly render a full interface using a standard XML parser.
A related standard, XSL, is a scripting language that transforms XML content. Objects that produce XML can communicate with a range of devices with no internal changes using XSL style sheets. This will allow the objects you create today to interact with new devices as they emerge.
Microsoft now includes an XML parser in its Internet Explorer and writes Office documents as XML. We can expect to see XML built into devices like palm computers and cell phones to provide a standard messaging architecture. Without XML, a programmer would need to write specific message formats for each device or use a messaging interface layer to handle message translation.
XML capability protects your investment in objects by making them adaptable to Internet devices without reprogramming.
The Internet is not the end of the road for mainframe computing, just the next great opportunity. Instead of being left behind, mainframe software can play a crucial role in the world of standards-based computing by adopting IP connectivity and the object model.
This all looks very promising, but like most new things, it can look daunting to the uninitiated. We’ll develop new skills that will change the way we develop software. For example, mainframe programmers will use new tools to wrap legacy programs as objects. These objects will run on application servers that can be scaled and tuned to provide high performance and reliability. Web designers will use XML and XSL to add value to customer relationships and trading partnerships. Customers and trading partners will enjoy more powerful, flexible information services.
The businesses that excel in this new world will see substantial growth, while those that fail to leverage their assets into this new world will be left behind.
The potential benefits of the Internet far outweigh the cost of new software tools and techniques. This time, we’re not looking for a way to replace a computing platform. Instead, we’re leveraging the power of our information systems to enable our businesses to prosper in a globally connected economy.
As the craftsmen who bring this together, we’ll know that generations of programmers were involved in the effort, but to the outside observer, our systems will present a conceptual integrity similar to that of the great cathedrals.
About the Author: Bill Braasch is the CEO of DBA Software (Emeryville, Calif.) and a member of ESJ's Industry Advisory Group. He can be reached at firstname.lastname@example.org.