Relationships go through phases: you meet someone, you get to know them better, you commit to them, you break up. The part everyone really enjoys is the second phase, the discovery phase.
Discovery is what drives programmers, usually. It's the push to do something new, to find a better way to do something, to alwas create.
This is a bad decision maker, really. It's fun, but you don't biuld a good marriage out of the discovery phase, you build a good marriage after you've get past all the wierd things she does in the morning and you see her without her makeup. The discovery phase is what attracts you to something, but it's rarely enought o actually make a lasting relationship.
So let's look at languages. Scala's a good example. It's new, it solves a problem well, and it has the clear and early benefit that it's not java and doesn't look like java.
So Scala fires up the feeling of discovery and people like it. That's where we are now, people are generally still liking it because they haven't really experienced it in the morning (or had maintenance brogrammers tell them that they don't understand some cool core scala feature so could they maybe fix the code.)
Actually, Scala may already be topping out here - people already see that the language isn't perfect. It's losing some of its shine, and some of the early adopters are already hunting for the next big thing.
For me, that's a good sign. I've looked at Scala. I can't say I really understand it yet, because i see how i could do what scala does with Java and other languages, too, and the normal way of doing things in scala seem to be more obscure than anything else. When "( _ . _ )" is acceptable code, it doesn't look serious to me. It looks like a kid's idea of what a joke should be.
But the fact that people are starting to look at it as if its a real language with real flaws along with its features, that's when the language starts to consider its long term health and growth, and when it starts to consider how to maintain itself for the long term. That means my investment in Scala is starting to turn from something that's a contact high to something that could actually be meaningful in the long run.
It's like a tool, you know? The torx wrench is really neat, and if you saw one in the store you might buy it. But you don't have any torx bolts, so the new wrench is going to hang out in your toolbox for a long time, probably forgotten except that you remember you thought it was neat.
But if torx bolts were to actually show up on something you own (which it might, I guess, because they're used in some consumer electronics) the wrench might actually get used, and you might learn what it's really good for (mostly annoying consumers like me right now, because torx things aren't standard enough to count.)
That's my whole point: there's a point at which new stuff is shiny and attractive, and that's great. Without the shiny aspect, we'd still be using cobol because we woudln't know or care what new things we could do. But at the same time, we need to be aware that there's more to life than discovery. you have to set up shop and get things done once in a while.
And since it's JavaOne and JavaFX just got released, I'll say it now: JavaFX is going to get some play from the early adopters who haven't gotten burned too badly by it already, just like JSF did. But it's going to go away unless Oracle rams it down our throats like a bad penny.