Just because we’re always changing doesn’t mean we shouldn’t
by Kevin Dangoor
Bruce Eckel is recommending that the Java language should be declared “stable” and left as is, rather than grafting on features that don’t fit well (particularly in the face of maintaining backwards compatibility). See: Java: Evolutionary Dead End. I agree with Bruce. As long as a high-degree of backwards compatibility is required, adding language features to Java will be clumsy at best. ECMAScript has the same backwards compatibility with forward movement challenges, but the language is much more flexible at its base, so I think ES4 can be a more successful evolution than Java 5 was.
Something interesting in this discussion is a comment from Vincent O’Sullivan that echoes the Scala Will Do cartoon from a couple days back. The implication there is that people in software development are always just chasing after the next shiny thing to help them with their projects… and, since it’s a joke, the implication is that people shouldn’t do that.
Software is the stuff of thoughts. It’s very malleable and new ideas can be tested out fairly cheaply. With the internet, new ideas and code can spread far and wide quickly. This is all a good thing. For me, creating software today is tremendously better than it was 5, 10, 15, 20 years ago. I watch many of the shiny things go flying by, but I don’t actually use them. But I consider the shiny things to be very important. There are all kinds of ideas wrapped up in there that can be applied in different contexts and with different tools. Some of the implementations that come out of those ideas will make it into the mainstream.
Generally speaking, people don’t switch to all of the shiny things that fly by. Some people will give them an honest try and will either be rewarded for being a successful early adopter or will suffer some pain and head back to other solutions. If enough people like the idea and follow through, it will become mainstream. Rails was the shiny new thing in 2004. There were undoubtedly people who felt the pain of being early adopters, but many more were far more productive than people using other tools that were common back in those days. Regardless of how many people ultimately adopt Rails, the fact is that many of the ideas presented there have had a significant influence on work that has happened since.
Scala is a cool language. There are many other cool languages, but the reason Scala is getting talked about is because it is more than a toy and it’s something that people can apply today. Until Scala has the kind of IDE support that Java users are used to, I’d consider the people using it to be early adopters. Regardless of whether Scala enters the mainstream, it contains interesting ideas and it’s worth looking at. I actually rather doubt that Scala will become mainstream, because the gap between its syntax and what mainstream programmers find “familiar” is too large. Steve Yegge made a similar comment about Scheme.
My point in all of this is that the way we write software is always changing and is generally evolving for the better. Look back on how you’ve created software in the past, and I’m sure you’ll find that it’s better today. If not, you probably haven’t been looking at enough of the shiny things that have flown by.