Ketchup, Java boy...
Monday, December 06, 2004
Once upon a midday weary, coding away trying to figure out which version of the Java API has a certain method I needed, I started wondering how am I affected by new releases of Java?
It is common knowledge that to master anything Java, you must spend a great deal of time reading, researching, and coding new examples with whatever API you are trying to learn, as the number Java technologies (APIs, Frameworks, etc) you must be familiar with grows daily.
In the big technology game we call the IT industry, we (developers) are but pawns, that play with the most important group, in my opinion, that is affected by the pace of technological advances: the business group. In other words, the companies requiring Java Engineers. This segment of the demographics is quite interesting in the way it maintains itself occupied with the new technologies.
In the beginning of Java, Sun did something similar to what Microsoft did while establishing their empire: cater to the developer. Aside from illegal business practices, and all the other horror stories you hear about, Microsoft, way back when, released usable development tools: the Visual Studio suite.
Sun didn't have to push a buggy operating system to the masses. All they had to do was to unleash a new OO programming language to developers (Who are eager to try anything new) and with a bit of luck, industry timing, and lot of smarts from Sun's employees, Java took root among some of the early adopter.
Most Java projects, I'm quite certain (I was part of a couple in 1998), started with one Engineer playing around with the new language, and he/she saw that it was good and brought up his/her results in some status meeting at some cold boardroom. If someone with guts and enough clout was present in such meeting, he/she escalated the findings to the next level and proposed the new solution, got a bonus at the end of the year for such great vision and innovative thinking, and Java became the standard for development tasks.
The Java industry grew out of the trenches, with the aid of viral marketing and word of mouth. The Java language spread all across the corporate world like unwanted spyware as new the new hammer to all programming problems (After all everything looks like a nail to a hammer).
Sun, at this point realized that they had stumbled into something revolutionary and decided to throw money at it to grow it as a business and, most importantly, as a Sun brand. Sun's plans worked only in one respect: Sun == Java, Java == Sun; therefore, Java is a Sun brand.
The only problem Sun has, and has had in the past, is that they don't know how to make money off it.
It's a great brand, yet they can't market their technology to generate direct profit from it. Just the fact, that I work with Java technologies (at a minimal cost; 0; nada; zilch), prevents them from generating any direct revenue from the sale of their APIs. The minute they start charging for Java, their development network will drop. The cost of learning would be to great. Thus, their viral marketing scheme, that helped them build the Java empire, would crumble.
Note: some would argue that selling a server to host a Java application is a sale that was generated because of Java. In the purest sense of the words "direct profit," I don't consider it direct profit, however, in the end, profit is profit regardless how it was generated. Also note, that I'm not debating that Java started a whole new industry and profits have been made because of it - Including my Salary for the last few years - My point is: Sun can't generate "direct profit" from Java.
Forwarding back to the present, Java has been, is, and will be a established Architecture/Technology/OO Language in the IT industry and so, with any mature technology, improvements must come. In Sunspeak, this means that a new version of the language comes out every year or so. That leaves us with about 6 different version of Java floating around in the corporate world: Java 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, and soon to be released 1.6.
Each version has incremental changes and each version also has some legacy code for backward compatibility. However, not every feature of the language is backward compatible (This fact is what led me to write this entry). And this is not good for Sun, nor the corporate world: there are too many choices of, essentially, the same (yet different) thing.
This evolution of the language, leaves the corporate world wondering which technology to support and which version to write their application with.
If a corporation has an existing Java application (Likely J2EE), there are 2 aspects that make the change of versions expensive:
- Application server costs
- Application development costs
Application server vendors (IBM, BEA, Sun, et al) probably like the idea of releasing a new server version every time there is a new Java version. Each new server release requires a new licensing agreement.
The corporate world, however, doesn't buy into the new technology as easily as the vendors would like. The main reason for this, is #2 above. Application development cost grows as the complexity of the development tools grows. It also means that the corporate world needs to spend time and money to train the existing staff with the new versions of Java, or spending the time to migrate an existing application to the newer coding syntax.
Either way, there is a cost of lost productivity allowing Engineers to learn new technologies or to migrate to new versions of Java - And if so, which one?
With costs of migration to the new technology, comes decreased revenue and hence, profits decrease - Share holders don't like the words "decreased" and "revenue/profit" in the same sentence, unless, the context of the conversation is gravitating around competitor's revenues/profits.
So, we have a couple of interesting phenomena with so many released versions of Java: the first one is that Sun doesn't make any money every time it releases a new version of Java; and secondly, businesses using Java are not migrating to the newer versions.
I already talked about the "no profit" for Sun, and as in terms of the business world not migrating, what is actually happening inside corporations' R&D departments is that some are developing to Java specifications that are 2 or 3 versions old.
It's a really expensive proposition for a Software Engineering shop to migrate to "Tiger," when most of your architecture is designed towards a J2SE 1.2. Some are using version 1.3, however, you don't see many 1.4 apps, and there will be less with 1.5 or 1.6.
Note: You may argue that if a system is well architected, there is no need to worry about the implementation details. In theory, this is correct. However, to design a large system, you must know what platform it will run under. So, the choice of technology comes into play early on in the design process.
Back to my original question, now that I have explored the impact on new Java version in the corporate world: what does this tiny bit of knowledge mean to Java Developers?
There are many aspects to explore, however, I will only talk about one: profits and revenue for the Java Software Engineer.
I can make my argument with aid of marketing and economics: there are early adopters to anything that is sold out there. For us, developers to be able to sell our services, we must ride stay on top of new technologies. I.e. If you are able to secure a contract or employment using 1.5 technology now, you are probably going to be handsomely remunerated for your efforts. Now, as the market gets diluted and more and more business start using 1.5 (or 1.6) standards, the supply of developers increases and your service will not be so much a luxury, but, more of a commodity (more developer out there == less pay for you). Of course, all that knowledge gained while developing with the new technologies is greatly valued, so you are still differentiable among the rest of Java developers and very much employable for the foreseeable future. I.e. someone will have to lead the new developers.
The moral of the story: early adopters of new development technologies will benefit greatly for their efforts. You must note, though, that the number of early adopters among the corporate world is limited - They are out there, but, you have look a bit harder to find them.
Having come this far, another question popped in my mind: should Sun stop releasing new versions of Java so quickly? And, should companies try to catch to up to Sun's release schedule, and migrate "old" code to newer versions of Java?
In the business world, it seems to be that the one with the most money will win the tug of war. And, there are more companies out there than there are Suns. So, I predict that companies will be a lot slower to adopt the new versions, though, I hardly doubt Sun will slow down their release schedule for the following reason: if Sun did slow down their release schedule, it will look like Java is dead in the water, and businesses will not have the incentive to migrate to a dying technology.
So, a business will migrate to newer versions of Java (Maybe one version at a time), slowly and at their convenience. I.e. Whenever there is enough money and enough time to do it. Apparently, abundant money and abundant time (man hours) seem to be in short supply.
In the mean time, I, as a Java Software Engineer, will ride the wave of the past, enjoy my present, and look forward to the future of Java. Thus, if you have an interest in securing my help via contractual work, I parley most Java versions - Even, the most expected Tiger version - Which by the time you read this, will probably be "old" news anyway :)
BTW, anything involving Software Engineering and Computer Science, interests me. Even if it's not Java related.
Obscure (or not so obscure) reference to the title: in Pulp Fiction, Mia Wallace tells a "not so funny" joke to Vincent Vega:
Three tomatoes are walking down the
I also need to attribute the first line of my introduction to Edgar Allan Poe's The Raven.
street, a poppa tomato, a momma
tomato, and a little baby tomato.
The baby tomato is lagging behind
the poppa and momma tomato. The
poppa tomato gets mad, goes over to
the momma tomato and stamps on
(STAMPS on the ground)
-- and says: catch up.