My morning started off with an informative presentation by Alan Bateman, the Spec Lead for JSR-203. JSR-203 is also known as NIO.2, the long-awaited update to the New I/O APIs first introduced in Java 1.4. I naturally have an interest in NIO since I wrote the book Java NIO for O'Reilly a few years ago.
NIO hasn't gotten much JDK love in the intervening years but that's finally about to change. The code for NIO.2 has just recently been approved for inclusion in the OpenJDK and is now available on java.net. NIO.2 includes datagram multicast, an extensive new filesystem API (file metadata, tree traversal, change notification, etc) and an asynchronous I/O framework for doing overlapped I/O with (optional) completion handler callbacks. As well as a host of smaller additions and tweaks.
Cliff Click's talk about developing lock-free data structures was fascinating. Intense, but fascinating. The secret to the highly scalable, massively concurrent algorithms he described is a rather simple Finite State Machine. By carefully defining how and when changes are made, hundreds or even thousands of threads can safely read and write a shared data structure without fear of reading stale information or clobbering another thread's update - and without using any locks. Read more about it on Cliff's blog.
As if that wasn't enough yummy goodness for one day. I met up with several friends for dinner, including Bill Venners who's co-authoring a forthcoming book on Scala. And who does Bill bring along but Martin Odersky himself, the creator of Scala. When Martin learned that I'd written a book on NIO, he perked up and said that Scala (especially Scala Actors) fit together with NIO very nicely. I beleve that Scala could turn out to have a serious impact on the Java/JVM world over the next few years. I'd like to see it getting more attention at next years JavaOne.
That's it for now. Time to trundle off to bed to rest my various aching body parts.
]]>But I also like to look into other interesting stuff, even if I don't have a particular need for it. I attended a couple of intriguing sessions yesterday and today that show off Java's ability to do some really stunning 3D visualization.
On Tuesday I went to the Project Wonderland talk. Project Wonderland is a virtual world, reminiscent of Second Life, that enables multiple people to interact in a virtual, real-time 3-D environment. It's built on top of Project DarkStar which is a Java-based multiplayer gaming engine. You can simulate a typical office setting, where you move about from one place to another, encountering and conversing with other people as you go. Or you can create entirely synthetic spaces to represent any "information space" that it would be helpful to "get into".
Today I attended a very interesting talk about the NASA World Wind project. World Wind is a Google Earth-like earth browser written entirely in Java that makes use of the JOGL library to achieve blistering render speed. World Wind has been presented before at JavaOne, but it's now been packaged so that it's easy to embed in just about any Java application or applet. I was impressed by how easy it is to setup and customize.
As I listened to each of these talks my imagination ran ahead, thinking of fun - or possibly even useful - things I could do with these tools. For me, that "What if..." response is always a good sign.
]]>
I focused today on fundamentals - specifically code correctness.
First up was a talk by Josh Bloch, More Effective Java, which highlighted several new topics from the forthcoming update to his seminal book Effective Java. I had the honor of leading an online discussion of Josh's book four years ago right here on java.net. The book is a must-read for any Java programmer who cares about getting the code right, first time and every time. I'm personally looking forward to the reading the updated edition, Real Soon Now.
I also attended Bill Pugh's cleverly titled Defective Java later in the day. Bill is the creator of FindBugs, a scary-good software tool that statically analyses your compiled bytecode looking for known problems. The thesis of the talk is that every coding mistake is a learning opportunity. Rolling those learned lessons back into FindBugs lets others benefit from your effort. If you're not already a FindBugs user, go get it and run it on your code. You will be amazed (and perhaps a little depressed) at what it turns up.
Late in the day it was Brian Goetz' talk about concurrency in general and the new fork/join framework that's coming in Java 7 in particular. Brian is the lead author of Java Concurrency In Practice, another must-read for any serious Java Programmer. The proliferation of multiple core machine means that, like it or not, we will all need to deal with concurrency - and get it right - sooner rather than later. The fork/join classes, particularly ParallelArray, will make it relatively easy to automatically apply parallelism to tasks that would otherwise be approached linearly.
These three guys are all leading lights in the Java world. They are (a few of) the people that have made Java what it is today and are shaping what it will be tomorrow. Any time you have an opportunity to learn from them, don't let it pass you by.
As the saying goes: if a job is worth doing, it's worth doing right.
]]>I work at a fast-paced startup and have only just returned from a two-week vacation. So I feel as though this JavaOne is sort of taking me by surprise because I haven't prepared for it as much as I usually do. And yet I already feel as though I'm right back into the swing of things.
The announcements and technical sessions at JavaOne have always had a lot of value, but for me the true value of JavaOne has always been about the people. It's the best venue I know of for making new friends and reconnecting with old ones.
Example: This evening (Monday) I drove up to San Francisco to pick up my badge so I would have it for the morning. I met up with a group of folks who are blogging for JavaOne. The group included Daniel Steinberg (an old friend and the former editor of java.net), Chris Adamson (the current editor of java.net whom I've met a few times before) as well as a few people I'd never met before including Josh Marinacci (sleep deprived) and Robert Cooper (beer deprived).
We hung out at a local eatery. Talked a little about Java, griped a little about Sun and marveled a little about iPhones. We talked a lot about books and the strange state of the publishing industry (turns out we're all book authors). Basically we sat around enjoying each others company, chatting about whatever came to mind. Friends, old and new, sharing common interests.
JavaOne is the place to be for Java people. But there is more to it than just Java. Your interest in Java is what you have in common with the 10s of thousands of other people here. You're among friends -- even the ones you haven't met yet.
]]>There is a lot of interest in scripting languages like Ruby, JavaScript and the new JavaFX running in the JVM. NetBeans is sprouting direct authoring support for a growing number of languages other than Java. There are so many language choices now that you can build a very sweet Java application without ever writing any actual Java code.
Is that a bad thing? Perhaps not.
The real value of the Java Platform has always been the Java Virtual Machine (JVM), not the specific syntax of the Java Language. Java (the language) truly was a big step forward for its time, addressing the perceived excesses of C++. It inspired huge numbers of programmers, both new and old, to write better OO code. But of the components making up the Java Platform, it wasn't the one that mattered the most.
It was the JVM that was the true enabler of the Java revolution. Compiling to a standardized intermediate byte code which can then be run in any compliant JVM was a huge innovation. It wasn't an original idea, nothing really is, it seems. But the Java VM was the first to become widely available on many hardware/OS combinations and thus the first to become ubiquitous.
Robert Tolksdorf maintains a list of dozens and dozens of languages that compile to Java byte code, or otherwise target the JVM.
Java the language will be in use for many years to come. But it may also be the case that it's in the process of being supplanted by various other languages. Some of these languages are specialized, targeted at solving specific problems. Others bring different philosophies and world views as alternatives to Java's syntax. But they all have the JVM in common.
Personally, I'm interested in the new language SCALA (there is a session by SCALA's inventor, Martin Odersky, on Friday at 1:30). It is an interesting mix of object orientated, functional and concurrency features. The syntax is concise yet type-safe and is designed to mesh smoothly with Java and the standard libraries inside the JVM. In my day job I deal extensively with XQuery, a functional language designed for querying and manipulating XML. XML is a data type that's built into SCALA, which makes for a logical bridge between my two worlds.
It's the JVM that enables this goodness. Over the history of Java, the syntax of the language has evolved and the libraries have bulked up. But the JVM has remained remarkably constant. Over the course of more than a decade of general availability, the JVM's evolution has primarily been in terms of optimization, stability and tunability.
Long after Java the language has fallen from fashion and faded into antiquity, the JVM, looking very much like it does today, will still be going strong. You may not recognize the languages in use then, but peek underneath and you'll find byte codes running in a JVM not too different from today's.
]]>Listening to these two sessions and chatting with a few folks here at the show, I'm more convinced than ever that concurrency is a looming problem that is, for the most part, going unrecognized.
As Brian pointed out, CPU speeds are leveling off. CPUs are not getting faster, they're getting fatter. In a matter of about a year, dual core CPUs have become the norm. I'm typing this right now on a dual core MacBook Pro. Quad core is becoming a reality in pro-sumer systems and sixteen core servers are not uncommon.
This sea change in the hardware space has many implications for we Java programmers. The first is the obvious one, that Java coders are going to have to get more sophisticated about concurrent techniques to get the most out of the runtime environments they will find themselves in.
But there's a flip side - a darker side, perhaps. A correct, single-threaded program will run fine on a multi-core machine, making use of only one CPU core at a time. But many single-threaded programs out there harbor undiagnosed concurrency bugs that never, or rarely manifest on single core CPUs. Here's a hint: finalizers are evil.
And then there are Java programs that are using multiple threads without well thought out locking strategies (or sometimes none at all!). On single core systems a tiny little race condition may never cause a problem. With more cores, more threads truly run in parallel, and more concurrency problems will come to light.
More cores means more broken code. Have you planned for it? Have you even thought about it? Will your code run properly under load on a system with 256 cores? Something to think about.
]]>I'm struggling a little bit to get a handle on what JavaOne 2007 is really about this year. From what I can tell, it seems to boil down to three things: open source, JavaFX and NetBeans.
Open sourcing the JDK is big. It's important and it will help insure Java's long-term survival. It's also going to take it in new directions. I'm glad to see it happen, finally. Five years ago it would have been a game-changing play, but today it's just the inevitable next step.
NetBeans has come a long way in the last few years. I tried it out recently to do some Java code profiling. I was impressed by how much it had improved since the last time I tried it several years ago. I would choose it over Eclipse without hesitation. But I use IntelliJ/IDEA. NetBeans has become the best IDE that no one I know uses.
That leaves JavaFX. I've only seen bits of it on stage. I don't really know any specifics about it and I'm sure a lot of very smart people devoted a lot of effort to it. But it gives me a sense of dejá vù. Why do we have yet another gratuitously incompatible JavaScript/Flex/ActionScript/Groovy/whatever kinda thing? I can't help but feel that Sun has reinvented another wheel. Five years ago, JavaFX would have rocked. Today it feels like me too and I fear that it will be an orphan tomorrow.
But I suppose it's to be expected. This year falls between major JDK releases. There are a lot of incremental fixes and improvements but no great leaps forward. I guess this is what a maturing industry feels like.
No worries, there are still lots of interesting sessions to attend and old and new friends to connect with. JavaOne is always a great place to be, even when you're not sure what it's about.
]]>But 2002 was a year when many things changed. It was the year when it became clear that the Internet bubble had burst, that .NET became a credible threat, Sun started losing money big-time and the bottom fell out of the technical book market - especially Java books.
None of this was readily apparent at the time, of course. I had a great time at my first JavaOne. It's become a cliché I know, but JavaOne really is about the people. At that first JavaOne I met my O'Reilly editor for the first time in person. I met other authors as well as a wide cross-section of techies, visionaries, pundits and fools.
It was great. I remember telling my wife that it wasn't just a show, JavaOne was an opportunity.
And so I kept coming back each year. But things were changing. Sun continued to struggle and JavaOne diminished a little bit each year. Microsoft was gaining ground with .NET. New languages like Ruby and techniques like AJAX where stealing mindshare. People were openly speculating about what would come after Java.
And I couldn't find a decent job.
One of the O'Reilly authors I'd met at JavaOne was Jason Hunter. Jason was doing some teaching about NIO and other topics. He offered to tech review my book and we stayed in touch, mostly by bumping into each other regularly at JavaOne. One day he got in touch to see if I might be interested in the company he'd recently gone to work for, Mark Logic.
I was. In 2004 I made a fairly radical left turn career-wise and joined Mark Logic. It's been a total immersion in XQuery and XML on a scale I'd never imagined before. Our product is written in C++ and it presents an XQuery interface.
That's not to say I never use Java anymore. There is a small Java component to our product and I continue my side interests in Java in general and NIO in particular - I've been a speaker at the last two JavaOne's in fact - but I can't really say that I earn my living with it day-to-day any longer.
So this is the first year that I debated whether to even bother with JavaOne. In some ways, Java is suffering from its own success. It's familiar, reliable and ubiquitous. But it's no longer new and different. It's just good old Java. And that's a good thing. That's what mature industries are built on.
I'm going to JavaOne this year. I'm going for the people. But I'm also going for the Java. I want to learn what Sun's open source strategy is. I want to learn about SCALA and I want to learn about dynamic minigrids. But mostly I want to learn by connecting with like-minded people and letting the waves of new ideas wash over me.
JavaOne is people.
]]>And yet, I just landed a terrific job at a great startup (thanks Jason). The work's interesting, I'm learning lots of new stuff and the people there are top-knotch.
I'm starting to get nuisance email solicitations from recruiters again. My independent consultant friends are complaing that they've got too much work. Things generally seem to be hopping. Is it just me or is there a larger shift taking place?
Have things turned around in Silicon Valley? Has the tech market finally begun another up cycle? Is it a dead cat bounce? The quickening of the stream before plunging over the precipice?
My instinct tells me that something's up -- that currents are flowing below the surface. Whether that means a sea-change for the better, choppy sailing or a tsunami approaching over the horizon, I can't be sure. But I do believe that life in Silicon Valley is about to get interesting once again.
]]>In this followup, Cringely suggests that the only way to beat Microsoft is to ignore them. If you allow Microsoft to define the rules of the game, they'll always win. Cringely contends that Sun is falling into the same trap with the recently announced Sun-Microsoft settlement.
He offers an audacious suggestion for Sun: Use Microsoft's settlement money to give every single Sun employee a paid six week sabbatical during which they must come up with new ideas to improve Sun, or leave. Like him, I doubt they will do it. But I wonder if the Sun of ten years ago would?
]]>Mr. Shirky describes his experiences while teaching at NYU and the approaches his students took when creating software for very specific, well-known social groups. He's basically talking about the opposite end of the spectrum from highly general, scalable, enterprise web applications.
I found his observations about how the situation in which the software is to be developed and deployed to be most enlightening. Should we learn to think outside the JVM?
]]>I was lucky enough to spend all of last week at Software Development Expo West (SD West) in Santa Clara, California. I usually don't have the luxury of devoting so much time to a "non-essential" activity, but the stars just happened to align fortuitously. My wife is expecting our second child soon and I'd scheduled myself to be voluntarily unemployed at this time anyway.
I can't remember when I've learned more or had a better time at a technical conference. It's not only because I'm more-or-less at leisure (and therefore don't have deferred work nagging at my subconscious) but also because of the people. As with so many things in life, it's the people that really matter.
I wrote a book for O'Reilly and have done a little speaking at various groups and conferences as time and opportunity have permitted. Doing so has allowed me to rub elbows with many fascinating and well-known folks that I'd never otherwise expect to meet. A bunch of them were at SD West.
Lords of the RingI spent so much time talking with so many people at this conference that I often found myself standing in rings -- slowly expanding rings -- talking to all sorts of people about all sorts of things. Most of them were wearing Speaker badges.
If you've ever attended a conference and spotted a well-known author (or several) standing around on the show floor talking with colleagues but were intimidated to approach, don't be. Most speakers when attending a conference are more than happy to talk with you about their field of expertise -- that's why they're there. Join the ring. Step right up. Introduce yourself. Odds are they're talking about email spam or something equally mundane and will be happy for a change of subject.
Good technical conferences (and SD Expo conferences are among the best) are extremely valuable resources. They bring together a critical mass of big thinkers and important information that you just can't find in any other venue. Exploit that resource. Jump in and interact with the like-minded people around you. Participate.
Everything I Know Is WrongSo, what did I learn at this great conference that I'm blathering on about? Let's begin at the end.
The last session I attended on Friday afternoon was by Allen Holub, with the provocative title "Everything You Know Is Wrong: Why Extends and Get/Set Methods Are Evil". This talk was based on a series of JavaWorld articles written by Mr. Holub (here and here, also look here). There are some deep insights here into the nature of Object Oriented vs procedural programming and how established practices are not always best practices.
At the end of this talk I knew I'd made these same mistakes and knew that I should have known better. I learned that I should constantly examine my assumptions, especially those I'm most comfortable with.
Rewind now to Day One. Most of the day I spent in a tutorial on Java Data Objects (JDO). JDO is a favorite topic of mine. I've used it in commercial projects and given presentations on it here and in Europe. I believe JDO is a great, under-appreciated technology that has yet to reach its full potential.
The tutorial on Monday was led by Kieron McCammon, CTO of Versant and a member of the JDO Expert Group. Even though I already know JDO very well, I still learned new things from Kieron. Later in the week, Craig Russell (Spec Lead for JDO) gave a presentation on the upcoming features planned for JDO 2.0. The forthcoming enhancements promise to make JDO a compelling solution for even the most demanding enterprise apps.
But the highlight of Monday was the lunchtime keynote by Steve McConnell, whose upcoming book Code Complete, 2nd Edition is highly anticipated. The first edition was published about a decade ago and the keynote was about how the software industry has evolved in that time. What I learned was that many of the principles underlying the Agile movement are not new and have manifested in diverse ways throughout the industry.
I also learned this week that Daniel Steinberg can never make it for lunch.
Jam-Packed CraniumsI won't bore you all with a complete rundown of my conference schedule for the week. But I do want to note a few don't-miss speakers that you should never pass up a chance to see.
Robert C. (Uncle Bob) Martin led a fascinating free-form discussion on Friday. It pretty much followed the subject matter of his amazing book, Agile Software Development: PPP, but ranged from speculation about parallel Hubble Bubble universes to the importance of 3x5 index cards. Bob Martin is one of the smartest (and apparently, nicest) people in this or any other Hubble Bubble. Whenever you have the opportunity, listen and learn.
I attended a very informative session by Mary Poppendieck on Wednesday about software productivity and lessons learned in recent years. Mary contends that the software industry is hurting right now primarily because of declines in productivity that have snuck up on us over the last few years, not so much because of recession or even offshoring. It's about process and processes in the software industry are often lacking when compared to more mature industries.
Jason Hunter gave a well attended talk on XQuery, a new W3C standard that's nearing completion. XQuery provides a standardized way of referring to and manipulating "jagged data" -- basically anything that can be represented as XML. XQuery is exciting because it could greatly simplify the task of working with the mountains of structured data that don't fit neatly into relational databases. XQuery is something to pay attention to (Jason too, for that matter). From Jason I also learned of a good burrito place in Sunnyvale.
The most entertaining event of the week was the evening keynote by pbs.org columnist Robert X. Cringely. One of the first things he said was "I used to be a developer -- now I'm developed". Funny guy. Smart guy. I can't remember much else of what he said. I was laughing too hard. I learned that back in the day, Apple must have been a hell of a place.
What Did You Learn Today?So why does my rambling about yet another tech conference matter? I think it matters, at least to me, because I was reminded this week that it's important to always keep learning. And to keep re-learning that you need to keep learning. It's very easy to settle into a comfort zone and engage the cruise control.
The software industry in general and the Java platform in particular are undergoing seismic shifts. To survive you need to stay current and learn to see the big picture. You need different perspectives, new ideas and the courage to take on new challenges in a world where the old rules may cease to apply, conventional wisdom may become foolish and Moore's Law can kick your ass.
Life RenewsA new life will be joining my family very soon. I look forward to teaching her. But more importantly I can't wait to learn something new from her each day.
What did you learn today? Who will you teach tomorrow?
]]>I'm generally in agreement with Eric on this one. I think Java needs to be open sourced to survive. James Gosling has even made favorable statements about open-sourcing Java. The current situation, where Java is buffetted about by Sun's corporate concerns, seems not to be good for Java (or Sun, for that matter).
]]>I realize that Sun is going through some tough times and are trying to reposition themselves, but I'm afraid they're hurting Java more than helping it as they go through these various jyrations.
We need less confusion in the market about the future of Java and J2EE, not more. Redmond must just love this stuff.
]]>Having been in the computer business for a very long time - the first computer I ever worked with used punched cards and was as big as my first apartment - I've seen a lot of changes in the nature and public perception of computing. And I can't shake this feeling that we're in the midst of a profound, evolutionary change.
In his now famous article IT Doesn't Matter, Nicholas G. Carr makes the argument that the IT industry is maturing and has become effectively irrelevant to a company's competitive strategy. In and of itself, Information Technology no longer has any intrinsic competitive advantage. It's simply one of the essential ingredients needed to run a modern corporation - like electricity, telephones and foosball tables.
But my nagging feeling is not so much about business trends as it is about similar evolutionary forces acting on the technology of software itself. Carr refers to earlier technologies that have transformed industry (steam engine, railroad, telephone, etc). Throughout their lifecycles, each has initially transformed - or disrupted - their environment and then themselves been transformed because of the changes they brought about.
I believe software development is entering such a mid-life, transformative stage - it's changing because of the changes it's caused in business and society.
Computers are no longer exotic, science-fictional wonders, they're a part of our everyday lives. And, as the off-shoring trend of recent years has made excruciatingly clear, programming is no longer a rarefied skill exclusive to a gifted few. To a large extent it's become a routine trade that almost anyone - anywhere - can perform. A commodity.
But the shifting economics of earning a living as a programmer is not what I'm talking about either. That's a political and sociological discussion. The thing that's nagging at me has to do with the programming itself. The way we as humans communicate what we want a computer (or a system of computers) to do.
Software has historically been inextricably linked to computer hardware design. Assembler languages gave us a one-to-one translation of mnemonic symbols to the numeric codes that a CPU understands. Higher level languages brought a more semantically rich set of symbols, and a more complex compiler to do the translation, but we're still essentially expressing ourselves in terms a CPU can understand.
Object technology helps us conceptualize things a little better. We don't feel so constrained to the lock-step, linear instruction execution model. But when you look inside an object method, it's still made up of those fine-grained marching orders for a CPU. We still seem to be tied to the paradigm of writing text that's translated to the CPU's native language.
I've been wondering lately if this notion, abstracted though it may be, of people writing text that's then translated into opcodes isn't something we've outgrown. It's the 21st Century but the way we as programmers communicate instructions to computers hasn't changed fundamentally since Grace Hopper started doing it nearly 60 years ago.
I saw a demo at SD West 2003 of the work Intentional Software is doing and have read a little about the Ace and Jackpot projects at Sun, all of which are exploring alternate ways of representing code. But I've actually been intrigued by this concept since I decided to switch to IntelliJ/IDEA as my Java development environment.
IntelliJ was the first IDE I used that was designed around the concept of language understanding rather than text editing (it may not have been the first, it doesn't matter, it was the first one I encountered). IntelliJ is such a great tool to use because it understands the Java language. It instantly checks code as you type it both syntactically (is it well-formed) and semantically (does this make sense in the context in which you're using it). It's the latter that's really valuable - manipulating text is not what I care about, it's getting the code right that matters.
Once I got up to speed with IntelliJ, I noticed a subtle but profound shift in my thought process. I began to think of coding less as a text editing activity and more as an object crafting activity. Because the tool understood the language I could trust it to do the mundane editing tasks while I concentrated on the higher-level meaning of the code. This has far-reaching implications.
Rather than thinking of the code as lines of text, I now conceptualize it as chunks of functionality that can be split, combined or reshaped as needed. The chore of making changes to the text files is handled by the tool. I'm able to devote my concentration to the more important aspects of programming: responsibilities, relationships, cohesion, coupling, patterns, and all the other stuff that makes for well engineered software. And when I see that something needs to be changed I don't hesitate because the tool can make the change easily - even if that change may affect a hundred source files. This makes for better code and it makes me a better coder.
Tools like this use a sophisticated internal model to represent the code. Where there's a model, there's usually a view of that model. And if there's one view, why can't there be others? When a tool can present your code to you as UML diagrams, color selectors, tables, live GUI widgets or whatever, the textual view we're all so familiar with starts to feel rather constraining.
So this begs the question: If tools can liberate us from mundane text editing and we code so much better when interacting with a more wholistic model, why do we bother to keep the text file representations at all? In today's world, it certainly seems as though building programs by manually munging text files is one of the least efficient - and most expensive - ways to go about it.
I don't know what the next great innovation in programming will be. It may be here already for all I know. But I do know that the labor-intensive, text-based programming method we've been using for the last half century will wane - it's simply not going to be economically viable much longer.
A friend of mine once pointed out that the majority of business programming is done not in Java, C/C++, Cobol or even Visual Basic, but in Microsoft Excel. I wouldn't consider a spreadsheet a programming language, but it certainly is an effective way for humans to communicate to a computer what they want done.
This, I think, is where the future lies. Finding the most appropriate way to communicate for any given problem domain. The era of humans translating their thoughts into sequential steps for the CPU to execute is ending. Just as high level languages supplanted assembler because they were more expressive and hid more of the details of the execution environment, I believe the next phase will be to move beyond the textual representation of programming logic for most applications.
Of course, conventional programming languages are not going away overnight. I suppose what I'm really talking about here is a new sedimentary layer being laid down atop what's come before. The future is alway built on the foundation of the past. The programming languages of today will beget the next generation of programming tools.
I believe we've reached the end of the beginning of the computer revolution. But we're nowhere near the end. Just as printing technology evolved from letterpress to linotype to offset to laser printer, the nature of programming must also evolve. It's going to be interesting to see which mutations survive in this brave new Darwinian world. In any case, I'll be sad when I finally have to say goodbye to my old friend, Java.
]]>