JavaOne 1998: A Watershed Moment
JavaOne 1998 was a watershed moment for me. For starters, that was the year of the Java Ring. And having cut my teeth as a programmer on embedded systems, the ring was super cool. Imagine Java -- the network-savvy language -- running on a multitude of useful devices all around you. Great, now let's get cracking already.
That was also the year when Enterprise JavaBeans were the rave (pun possibly intended). Until then we'd been rolling remote services by hand using RMI and CORBA and using proprietary O-R mapping tools, if we were lucky. Everybody seemed to have a database chock full of data they wanted to expose to the world, and entity beans made that task all too easy. Yes indeed, at that point the network certainly became the computer and then we wanted to make it all go away. Sessions beans -- arguably the crown jewels of EJB today -- were perceived as being too simplistic in comparison. Hey, but what about my database? No doubt, if you were resume padding then you definitely wanted to be able to say that you'd gotten your hands dirty with entity beans. And so it began.
JavaOne 1998 was a watershed moment for yet another reason: I landed a new job. Oh, you better believe I was packing a resume or ten when I showed up on Day One. But my resume made no mention of Enterprise JavaBeans. No, it would take another year or so at my new post painfully swinging the EJB golden hammer before I earned those bragging rights. And believe you me, as early adopters of the technology we paid a very high price blazing new trails. We made all the common mistakes and then some. In the end, it wasn't the technology that let us down. We wanted it to work. It just took us too long to realize that it was the entirely wrong tool for our job. In retrospect, those painful lessons aren't worth bragging about. Indeed, it took me another three years and many more lessons learned the hard way before I could bear documenting the blood, sweat, and tears in Bitter EJB.
So while you're at JavaOne this week, above all else have fun and meet new people. Years from now when the glow of new technology has faded, your fondest memories will be of those good times and friends. And while you're trying to grok all the new APIs and tools, remember that at the end of the day it's all about building software that has value to its users. I find that much more gratifying and rewarding than sporting a well-padded resume. That said, you'll likely learn about a new API or tool this week to help you get the job done better and faster. (That's what your boss thinks you're doing anyway!) After the fun and people, JavaOne is all about culling for new ideas. By all means, use what you find to your advantage. But remember that as an early adopter you'll need to be extra careful. Before diving headlong into the deep end, consider wading into the pool using the following techniques:
- Practice with learning tests. Before writing production code using a new API, write learning tests that let you poke and prod the software to see if it reacts as you expect. Once you've codified your expectations in tests, you'll have a handy collection of working code to draw from.
- Don't bet the farm on new technologies. Start a pilot project, prototype, or technology spike to learn as soon as possible if it's the right tool for your job.
- Let others blaze trails for you. Subscribe to mailing lists and forums where other early adopters are discussing their successes and failures with a technology of interest. Make sure to contribute your own experiences.
But what about the Ring? Well, things seem to have come full circle since 1998. Witness the new Java logo. If things go as Sun plans, you'll be seeing the new logo pasted on a multitude of computing products going forward. As for Enterprise JavaBeans, well, let's just say we've learned a lot since 1998. ;-)