The Right Way To Scale

Sometimes a problem is hard to solve not because it’s actually hard, but because you pick a hard solution to a simple problem. On the other hand, some problems really are hard; even if you pick the best solution, they’re still hard. If you pick any other solution, you fail.

Writing and running enterprise servers and Internet servers that scale is one of those problems that really is hard. I’m talking about the really successful sites that we all know about: stock trading, auction, big retail and industrial sales sites. Sites so visible that when they crash, it makes the next day’s financial news. Here’s what characterizes successful sites:

Scalability: They handle enormous loads with ease, because their load-balancing architecture spreads tasks across a number of machines.

Fault-Tolerance: They’re always up, because their fault-tolerant architecture is redundant in hardware and software.

Transactional Reliability: Their transactional architecture makes processing reliable. Without this, high interaction rates inevitably lead to high error rates that are expensive to correct.

Security: They are secure in both hardware and software. Since all of the sites we’re talking about deal with either money or items of substantial value, security of programs and data is critical.

B2C sites and B2B sites are different. B2C clients run browsers, communicating over HTTP. This isn’t elegant, but it works. Error rates stay low because orders are keyed in by actual people who can check for mistakes. Errors don’t matter that much anyhow – there are so many clients out there that if a single order goes awry, your business will survive.

But B2B is different. In the beginning, business clients may be satisfied with placing and checking orders on browsers. But that doesn’t last long. Soon, companies want to connect their assembly line just-in-time stocking program to their suppliers’ ordering program, and their accounting program to the suppliers’ billing program. How many transactions could this involve? How many different parts are there in a 747? A lot! And, suddenly, even small errors matter.

We can’t perform B2B interactions the same way we do B2C, because the client-browser model doesn’t have the reliability that B2B requires. Client and server machines are owned by different companies and don’t trust each other, or share an architecture, or even a business or domain model. How can we standardize on a scalable, robust, reliable and secure B2B e-commerce environment but still maintain respect for these infrastructure differences?

Into the breach steps XML – extensible markup language. XML has a lot to offer as a solution to the modelling part of our problem, and this is one reason why it’s being received so enthusiastically by Web developers. Unfortunately some people see XML not only as a language for expressing business concepts and other structures, but also as an interoperability solution. This isn’t true: XML is only a data format – there is no single, standard communication method associated with it. Instead, people transmit XML in lots of ways including HTTP, SMTP and over message-oriented-middleware (MOM) systems.

These work, in their fashion, and they’re fairly quick to implement because they reuse existing software. But how do they measure up to the characteristics we listed above? They don’t: HTTP and SMTP were never intended for this severe use, and MOM implementations lack the uniformity needed for industry-wide adoption.

In order to succeed, a distributed B2B e-commerce environment must couple client and server with reliable, secure, platform-independent network interoperability. At the same time, the extensibility of XML must be preserved. This must all be built on a robust, scalable, transactional server foundation. Corba, specified by the Object Management Group (OMG), meets these requirements now.

To Corba, the computing industry’s interoperability standard, the OMG has recently added reliable messaging-mode asynchronous network transport and a mapping from XML to OMG IDL. This lets enterprises link their systems for B2B commerce using Corba, without sacrificing either the extensibility of XML or the loose coupling and assurance of MOM. With these additions, Corba meets all of the requirements for B2B e-commerce: scalability, fault-tolerance, transactional reliability and security.

Jon Siegel is the director of technology transfer at the Object Management Group, a Needham, Mass.-based not-for-profit developer of vendor-independent software specifications.