Advancing Application Platforms: The Twilight of Vendor Consortia
Sunday, November 04, 2007
After graduate school, I worked for a while as a Unix developer, then spent several years in the networking standards world. I was a true believer in the value of these standards, and I remain one today. Without real standards, interoperability isn't possible.
Yet in the mid-nineties, I consciously changed my focus to the Microsoft world. I didn't make this switch because I thought Microsoft technologies were inherently better--they weren't, especially then. Nor did I stop believing in the value of standards for interoperability--they're essential. Instead, my attention had moved to application platforms, where standardization efforts emphasize portability rather than interoperability.
Portability is a more forgiving goal than interoperability. With networking standards, both sides must follow the exact same rules, or communication isn’t possible. Standards for portability allow lots more wiggle room, and so vendor and personality politics can more easily trump both customer requirements and good technology. It didn't take me long to decide that this was no way to run an industry. Providing portability across application platforms from different vendors while still making technological progress looked hopeless.
The big Unix vendors promptly proved me wrong. By rallying together around J2EE in the late 1990s, they were able to create a more or less common platform that provided first-class support for that era's enterprise applications. All of them were afraid of Microsoft, and they were able to work together quite well for several years.
This unity is now breaking down
. It's not entirely clear why this breakdown is happening today, but one possibility is that the enterprise Java vendors have forgotten who their real competitor is. Spending time in the enterprise Java world often leaves me with the sense that these vendors focus more on competing with one another than on making common cause against their shared enemy in Redmond. Whatever the reason, the personal and political agreements that kept the enterprise Java world together are fraying.
Just as important, the kinds of innovation needed today often require a more unified approach. Think about Microsoft's Language-Integrated Query (LINQ)
, for example. LINQ requires changes to programming languages, development tools, and the application platform. Microsoft owns all three--C#/VB, Visual Studio, and the .NET Framework—and so it can make these unified changes. Trying to provide a similar technology for Java would be more complex: Sun owns the Java language, Eclipse is open source software, and each vendor has its own platform. Accomplishing this kind of multi-factor innovation in such a divided world is no easy thing.
Microsoft's recent Oslo announcement
provides another example. The goal of Oslo is to create a broad set of innovations touching many aspects of the application lifecycle, including languages, development tools, integration, application management, and more. It's too soon to know which parts of this very ambitious project will succeed. Still, it's hard to believe that these broad changes across many connected technologies could be done by standards committees. Too many groups are involved with too many competing vendors.
If even some parts of Oslo are successful, enterprise Java vendors will need a new approach to creating its competitor. Especially when change must happen in a unified way across many technologies, standards committees don't work. Even groups less formal than standards organizations, such as the Open SOA group that produced Service Component Architecture (SCA)
, have a hard time creating effective standards for application platforms. While the vendors behind SCA were able to agree on a set of standards, for example, they can’t seem to agree
on which of those standards to implement.
It looks like the years of J2EE unity were the high water mark of vendor agreement. I wouldn't be surprised if five years from now the dominant vendor platforms are provided by Microsoft, IBM, and Oracle. The last two will both use the Java programming language, but they’ll vary widely in other ways.
We're headed for a world where the big vendors are forced to strike out on their own. It’s had a good run, but the era of vendor consortia for application platforms appears to be drawing to a close.