We are participating in the biggest shift in the way computers are used since the PC was popularized nearly fifteen years ago. Employees are breaking away from the confines of their offices and taking to the road. Virtual corporations are springing up and with them the demand for new types of portable computing capabilities. As integrated circuits and microprocessors get progressively smaller, computerized intelligence is popping up in unexpected places, from mini cell phones and wristwatches to smart credit cards, telephone displays and digital ink painted on walls. The functions performed by yesterday's computers and telephones are starting to insinuate themselves into our home appliances, our office furniture, even our clothing - a concept known as "ubiquitous computing."
As mobile work forces and portable computing devices become more and more popular, we software developers are challenged to construct highly streamlined, platform-independent business applications. Fat PCs and bloated applications are giving way to slimmed-down desktop clients, lightweight computing devices and object-based software. Corporate developers are struggling to extend access to the corporate information sources that formerly could be reached only from the well-worn office chair.
This change forces companies to rethink the way software should be architected, distributed and used. Applications and databases must be small so they can be readily delivered across the Internet, and they must be portable so they can be deployed on both new and old computing devices. They have to be well connected, since data is going to have to be moved back and forth between nomadic applications and the corporate data sources.
The software fabric for these new types of computing solutions is being woven from distributed object technologies such as Java. Java programs are compact, portable and can be designed for low-bandwidth constraints. Java programs can run on any platform that supports a Java VM, including nearly every type of computer and, soon, Personal Digital Assistants (PDAs), public kiosks, smart phones and a variety of wireless devices.
What does an application look like that is designed to run disconnected, perhaps on one or more of these emerging platforms? Surprisingly perhaps, the answer is: much the same as the typical corporate applications that we deal with today. Enterprise applications these days are typically built as a two-tier or a three-tier affair. Commentators call this n-tier architecture. The client tier looks after interaction with the user, the database tier manages data access and data integrity and between the two may be a third, application server tier that executes the business logic.
This logical three-way division of applications remains valid even when the client becomes thin or disconnected. What changes is that all three tiers may need to execute on the same client machine. At first glance, this seems strange, since some of the impetus behind multi-tiered architectures is to put the right processing on the right machine for each particular task. However, in many kinds of applications there is only one machine involved at runtime so there is no option to distribute logic to alternative locations. With only a single machine to play with, the three tiers become a logical abstraction helpful in designing the application, rather than a description of how it is implemented.
Imagine an application, written in Java, containing an embedded programmable data manager and running on a disconnected thin client. Once a day or so, the user plugs the machine into a phone line or LAN and resynchronizes with central databases. The application manages user interaction, business logic, data integrity and data access. But the boundaries between the tiers become very porous as a Java method takes a field from the user and passes it as a parameter to an order entry method that executes transaction methods against the data manager. This in turn acts as a client to an operational database at the other side of the country.
As database systems get smaller and more mobile, data management tasks can be distributed to any object, anywhere in the system, even to devices that we are not accustomed to thinking of as computing platforms. Any client can run an application server and a database manager. The fabled n-tier architecture, long sought after as the Holy Grail of distributed computing, becomes an any-tier architecture.
About the Author
Nat Wyatt is co-founder of Cloudscape and serves as its chief technology officer. Before founding Cloudscape, he was a senior architect and development manager at Sybase. Most recently, he led the team developing the Brahms project transactional object store. He also was a key architect for SQL Server and redesigned SQL Server to run in multi-processing environments. He can be reached at [email protected]