With SCA, reality bites J2EE again
But is that the whole story?
Analysis With the announcement last week by IBM, BEA, Oracle, SAP, Siebel, IONA and others that they are collaborating to develop a language neutral programming model tuned to the needs of SOA initiatives, it looks like a little more lustre has rubbed off J2EE. But it also looks a little like something deeper could be going on: the biggest vendors are shifting their attention to a wider market opportunity. Can they avoid the mistakes of J2EE?
J2EE was originally designed with serious input from IBM (based on its ComponentBroker middleware project), BEA and others – as well as Sun – to standardise a programming model for building web-based business applications. It arrived in the dot.com boom, when the world was awash with small innovative suppliers selling middleware which combined web servers with support for object-oriented programming, and transaction handling against remote databases; and outwardly at least, the idea was a good one – the argument from the authors was that without a clear standard in the market, the cost of developing skills and the risk of vendor lock-in would hold the market back.
But for some years now voices in the software development community briefing against the suitability of J2EE for various types of work have been getting louder.
"If it ain’t J2EE, it ain’t going to do the job"
I’m happy to admit that there’s long been a conspiracy theorist living in my brain, telling me that J2EE was an attempt by the established players (IBM, BEA and Oracle, aided by Sun) to lock small vendors out from the Java application server market opportunity. For most of the time the primary "evidence" to support my feverish imaginings was the fact that certifying products to J2EE has always been expensive – and it has become more expensive as the specification has become more complicated. Small vendors had real trouble getting the resources together to play that game. Now, though, I’m starting to think that the increasingly audible developer discontent with J2EE adds fuel to my fire.
It is entirely possible that J2EE was developed altruistically by the folks involved in the process. However good the original intention was, though, the large vendors’ sales and marketing teams have certainly been happy to associate complete J2EE compliance with the ability to deal with real-world requirements in customers’ minds.
Innovation always finds a way
The shine on J2EE started to dull when a core element of the Enterprise Java Beans (EJB) element of the J2EE programming model, Entity Beans, started to be seriously tested by developers – and many declared it to be too clumsy and inefficient to provide the facilities which were advertised. Curiously, given its stated intent, as well as its shortcomings in helping developers manage persistent data, the J2EE model also never really offered design patterns to help people building web-based applications become productive. More recently, the specification has received brickbats for failing to really get to grips with the challenges of developing and deploying web services.
On top of this, J2EE is managed by the Sun-led Java Community Process (JCP), which has, in all core Java-related areas, eschewed the creation of royalty-free specifications. This is combined with the fact that as J2EE has moved through a handful of major revisions the specification has only become more difficult and expensive to certify against.
More and more Java development shops have been looking to (open-source, royalty-free) frameworks like Hibernate, Spring, Tapestry and latterly Struts – supported by "professional open source" vendor JBoss and vendors with "blended" approaches like BEA – to help them build the kinds of applications that the J2EE specification was originally designed to help with. The JCP has learned some lessons from these frameworks in the new Java Server Faces (JSF) and EJB 3.0 specifications, but the alternatives continue to thrive.
And at the same time as all these J2EE-related shenanigans have been going on, Microsoft has been steadily plugging away at its own .NET programming model – introducing features to hide the muckiness of dealing with web services and various proprietary integration technologies; offering a variety of ways of processing and managing persistent data; as well as making it relatively stress-free to develop client-server applications which can seamlessly work with or without network connectivity.