FullerData.com - Got Me Some Java Religion

Back in 2001, when Java /J2EE and C#/.NET flame wars were going strong. The same perspective applies for [Insert Technology Here], which was really the point. Ironically, Java very much established itself and has been used in areas not originally argued and approaches that would not seem practical at the time, become the norm as technology marches on. Likewise, the general paranoia against Microsoft from many technical tribes has long since abated as the world moved to an always-connected and mobile-first model with firms such as Google, Amazon and Facebook becoming the bigger players and the ones with their own controversy. Not to mention Cloud and Open Source transformations, the technical world changes a lot as decades whoosh by! (March 2019)

Got Me Some Java Religion

(Originally Published 19th Dec 2001 - AngryCoder.com)

So what is the deal with these Java guys? We get more than our fair share of personally-challenged individuals in this industry and many seem to hoard around some new mega-hype technology. Based on very little, these individuals crusade as to how this new way revolutionizes everything that came before. They ridicule anything that doesn't fit into their new model, mock the intelligence of anyone who disagrees and feel they can occupy the moral high ground.

This is not an anti-Java article. Many of us have seen all this before, lived through it and even partaken in many of the crusades as the rally calls are made. Can the same be said of other engineering principles? Do bridge or airplane designers start a new crusade every few years, demanding all old bridges and aeroplanes were rubbish and should be pulled down and replaced with virtual bridges or virtual airplanes?

In angryCoder tradition, this article is serious flame-bait and attempts to address some of the pretensions within the Java and general developer community.

A Brief History of (Java) Time

Do you remember 1995? This is when the Java hype machine started. This was a fantastic new technology, completely revolutionizing everything on the Internet, hell it was the Internet. The language itself was another C(++) derivative, along with a supporting class library and an interpreter (Java Virtual Machine) to run the compiled portable bytecode. Whilst Visual BASIC had the ongoing "stigma" of being an interpreter on the Windows platform, with the moral high-ground going to the C++ gang (ironically, one argument also being re-compile portability of code to other platforms, with changes to the presentation layer), Java managed to make it's use of an interpreter a positive, by playing heavily on the "write once, run anywhere" card.

None of that crappy HTML stuff, we could now automatically deploy whole applications down to the workstation. Some of the forerunners of this new crusade jumped in feet first, forgetting those passé Windows, X-Windows or Apple Macintosh applications - now we can execute common code on any of these platforms. It was the classic case of letting the technology drown out client requirements, who really wanted fast, cool-looking, fully-functional applications. Instead, the client's got a collection of embarrassing applications that ran like a snail and not surprisingly, the golden age of Java applets has faded, although there are still the die-hards who will argue white is black.

In the meantime, Java re-invented itself for the server side under the name of Java 2 Enterprise Edition (J2EE). The value proposition this time was that instead of running on the client workstation, the Java Virtual Machine was run on the server, along with a number of interesting additional technologies, such as Enterprise Java Beans (EJB). Sun created the specification of the technologies, along with reference implementations, and confusingly it's own product line. A large number of J2EE vendors also implemented their own versions, although most of these implementations eventually drifted into obscurity, with a few big players remaining (such as BEA, IBM, Oracle and of course, Sun). The value of each vendor being the quality of implementation and proprietary extensions, which differentiate them from the other guys.

Although J2EE is designed specifically to run on any platform, given the nature of running under a VM, realistically Unix (or Linux) became the main target. If nothing else, this did give an alternative means of producing software for the software-starved and innovation stagnant Unix platforms. Some would also argue viable usage on a Windows platform, in spite of the tightly integrated COM(+) capabilities overlapping the J2EE functionality. There was also the issue of standardization, with Sun playing a few games with standards bodies, but eventually deciding they really wanted to keep full control themselves.

The Java platform enjoyed a respectable amount of success and a large amount of developer mind-share, especially amongst the crusading groups, picking on the Visual BASIC masses and putting up a spirited fight against the battle-hardened C++ developers. These were the glory days of .com, when business models, income and amount spent on application servers was not seen as relevant. Finally, some pragmatic common-sense came through and many of the income-challenged companies disappeared leaving little evidence except a mess of the stock markets.

A Brief History of (Microsoft) Time

Do you remember 1981? This was the time of MSDOS 1.0, and depressingly the final version of MSDOS extending to 1994. That's all I have to say about that, DOS was a toy OS, but at least we could afford the hardware it ran on.

How about 1983? Apple released the Apple Lisa, followed by the Macintosh in 1984. In 1985, Microsoft released the first version of Windows and unlike the Apple implementations of a GUI, it was under whelming, being basically an MSDOS application. Windows 3.1 was widely used, although finally reached a level that was competitive to Apple in 1995 with Windows 95. This code-base continued as Windows 98 and Windows ME - and you could still play your old DOS games (mostly).

In the meantime, Windows NT was created from scratch and introduced in 1993. Unlike the versions of Windows that were actually DOS underneath, this was designed to be a "proper" operating system. It still wasn't as stable as Unix, but it was a heck of a lot better than DOS. Windows NT4 moved the user interface to look like the popular Windows 95 (rather than Windows 3.1) and eventually itself got replaced with Windows 2000 (really NT 5), which is actually very stable. Recently we have Windows XP (really NT 5.1), which is meant to replace the legacy DOS Windows, as well as being the next in the NT line.

Also in the meantime, something wonderful was happening. Microsoft were stumbling around with RPC mechanisms, using DDE and then OLE. You could basically control applications using well defined interfaces and this turned out to be COM. A component-based transaction monitor and distributed components were then added as part of NT4 in the form of MTS and DCOM. Suddenly, the Microsoft platform finds itself as one of the most advanced development platforms, supporting a highly integrated transactional environment - shame you still had to be very careful to keep it stable. COM, DCOM and MTS merge as an evolution under Windows 2000 as COM+ and things are looking much more stable.

And then there's .Net, with COM+ still being the building blocks of the operating system, but much of the complicated stuff now being hidden in a "virtual machine" sitting as an abstraction above it all. So Java had some pretty good ideas after all. Shame it's only for Windows though, but hang on, what are those open-source boys doing with the ECMA standard of CLI and C#? We'll see.

A Brief History of (Unix) Time

The first Unix machines were introduced in the early 70's. Basically a portable OS written at Bell Laboratories in C (which they also wrote) and only the core kernel needing to be re-written for a specific platform in assembler. Mainframe users took the moral high-ground, quoting the standard reasons of immaturity and poor security (errrm, the same argument the Unix guys then used against Windows). Academics loved it and many of us were dedicated followers of VT100 screens.

The Internet still uses a lot of the technologies first found in Unix, we owe it an awful lot. The excellent X-Windows was introduced in the late 80's, although many operations were still easier/essential to do from command lines - so you ended up with a fancy GUI workstation running a large number of X-term windows. Microsoft Windows is only now beginning catch up to some of the X-Windows thin-client concepts, with Windows Terminal Server.

The biggest issue with Unix was it's by-design openness, despite efforts to standardize, everyone and their dog implemented their own kernel and variation on Unix (with really imaginative names, mostly ending in ix or ux or is). The reason was competition and the desire to make money in the real world, which resulted in a fragmented Unix market and eventual stagnation and lack of applications. The last refuge being the high-end market, given that Windows only ran on the Intel platform, with it's more limited single-box scale-up capabilities.

And then there is Linus's Unix (or Linux) and the open-source crusades join together under a new (or GNU) banner. Hopes were high in the brave new "we don't need profit" .com world, but the vicious reality of making money eventual burst a few idealistic bubbles. Whilst Windows has become a component-based rapidly-developing operating system, despite the open-source pretensions of mass part-time development, there is nothing revolutionary appearing (or likely to) on the same Unix platform it always was. Hopefully it will manage to survive in the niche's where Unix has been over the last many years.

The Mainframe is Dead!

Long live the mainframe. The mainframe has been pronounced dead on many occasions, but IBM keeps making money on them and most large businesses are deeply dependent on them. They're not going anywhere, despite the discovery over Year 2000 that many businesses don't really know the details of how their mainframe and hence business is run. The Java and Linux crusade is getting some support from IBM, but let's be realistic and understand they just want to shift some more very expensive boxes - they will drop Java/Linux in a heartbeat depending on what makes money.

BCPL Begot B Begot C Begot C++ Begot Java Begot C#

So Java is a new revolutionary language? Errrm, well, NO! Those with a C/C++/BCPL or whatever background find it all VERY familiar, although the class library is very decent - using the C concept of a small language and therefore the library is the language. Let's not pretend any great innovation with Java or C#, these are very small variations on the same languages we've been using for a long time.

Languages such as COBOL, are still the most widely used, given the heritage from the mainframe - and now .Net versions of COBOL might allow those programmers to keep to something familiar. A good thing about .Net, is that it provides a standardized platform for some more innovative languages to start appearing, probably out of academia, to potentially reach mainstream audiences (such as Visual Programming, and we're not talking form design here!).

So Open My Brains Fell Out

I never quite understood the open-source gang. I like the concept of freeware or shareware, for those small or older applications you want to distribute to a wider audience (and perhaps make a little money from shareware). You might also give the source code away, or perhaps sell it on request.

Now, sharing the source code within a "community" project is also a very cool concept. If people really have the time for this, perhaps using is as a learning experience or hobby, that's fantastic. A good example for me (as well as GNU or FreeBSD of course) being the MAME arcade emulator - lots of people writing hardware emulation out of sheer love.

I can even understand the open guys wanting to protect their community code-base from commercial use, but why the crusading, anti-money, idealistic baggage? Most of us make a living out of writing software (feeding the kids etc), given most are not employed in Academia or studying for future careers. So, by all means have fun, add value, but the anti-capitalist attitudes are really tiresome!

The Anti-Microsoft Club

So why is there such a passionate hatred for all things Microsoft amongst some of these groups? All this monopoly screaming seems like a lot of sour grapes from the competition who have not faired so well, but this is capitalism!

Many of the Nintendo-playing, JVM-weaned Java-kiddies passionately shout about the evil Microsoft empire, joined by the die-hard Unix guys who are still bitter about the mass-market juggernaut of the Microsoft technologies. Microsoft continue to target the general populous and sheer volume allows them to price their products competitively, whilst also pumping huge amounts of money into making the products themselves of increasingly higher quality. They seem to have the ability to learn by their mistakes, and like all vendors, have made quite a few (like the famous Internet U-turn).

Microsoft will not be dominant forever, but while it is in such as strong position, let's let them add value rather than bog them down in childish anti-MS (or M$) sentiment seen in some forums.

The Next Crusade

So many of us are very excited about .NET. This is probably the next big crusade, with recent ECMA (and fast track ISO) approval of the CLI and C# specifications. Along with a couple of open-source Unix efforts based on these standards, it seems that Microsoft have assured themselves of the next mass-market.

There will still be room for native COM+/C++ development (perhaps still desirable for high-end applications) and the J2EE crusade will continue, but I expect that J2EE will remain with Unix as a niche technology, not really achieving the critical mass required for the mass-market momentum that Microsoft technologies have enjoyed.

J2EE still lacks any viable performance metrics, such as the independent tpc.org, which is now getting overwhelmingly suspicious, especially when the same J2EE vendors also have multiple non-J2EE TPC entries. The more limited single-box Intel platforms are using a distributed architecture to "scale-out" with farms and clusters to achieve very high performance, whilst the mainframe model of a single box "scale-up" architecture which was the Unix niche, is proving to lack cost effectiveness and overall scalability.

Even the safe-play of the "J2EE vs J2EE" ECPerf metric, introduced by Sun, has a very reluctant acceptance (as of writing, only Borland have published any results!). Combine this with a standards-based .Net CLI, along with an army of ever evolving languages, and the aggressive Microsoft marketing boys look like they've finally pulled the J2EE camp away from the moral high-ground into a pragmatic reality.