Haskell is one language where i encountered that too often, whereas Clojure's Windows support does not feel second rate. The portability of the JVM and Java's libraries combined with a joyful functional language like Clojure is very attractive.

It's kind of similar to the feeling you get once you've programmed in a language with GC. You really don't want to go back, unless you have to.

Now that the JVM is really running just about anywhere it has become a viable platform to target, and java is just one more language that targets it.

Clojure, groovy and scala are built on top of the JVM, but there are also plenty of languages that are available on mutliple platforms.

Whoever came up with just-in-time compilation deserves a gold medal, without that none of this would have ever happened.

My understanding is that JIT in Java is a variation on what the Smalltalk world called dynamic optimization. That was introduced into Smalltalk by Peter Deutsch and Allan Schiffman in the 1980s, but I don't know whether or not they invented it independently.

That invention pre-dates java itself by quite a few years, but then again, java has a lot of elements in it that were considerably older, iirc there was UCSD pascal P-code, which was another virtual machine like environment with an abstracted machine, and the 'forth' language which has quite a bit in common with how the JVM operates on the lowest level.

I was just reading that 'early history of smalltalk' thing the other day, and it struck me as though really, since the 60's there hasn't been that much progress at all.

The 'mother of all demos' combined with the 'dynabook' (iPad?) really pretty much covered everything with the exception of the mobile phones.

Sure, we all have the equivalent of several Cray-1's in our houses now (or even in our pockets), but conceptually we are still were we were back then.

Everything looks great, we're burning billions of cycles on spiffy user interfaces and showing movies.

But under the hood it's old hat.

That's why I keep circling around and around trying to find my new 'home', the environment that I think will last me for the next 10 or 20 years.

I haven't found it yet. All I see is endless repetition, configuration files, minor tweaks. Rarely a bold move (fleet comes to mind, but I don't think it will ever be a commercial success). Programming seems to be mired in endless detail, fiddling the bits and tweaking things to get a link here or a widget there and to get them to talk to each other. User interfaces have become the main focal point, when they weren't (or at least when they weren't as pretty) we were happy if stuff just worked.

I feel like a homeless guy looking for a place to stay.

Clojure might be it, I don't know...

but I'll try it for sure. No point criticizing the soup before you've eaten it.

Thanks for digging up that jit reference.

"Generalizing the idea for the full set of operations, we can write an on-the-fly compiler that translates the current regular expression into special code optimized for that expression.

Ken Thompson did exactly this for an implementation of regular expressions on the IBM 7094 in 1967. His version generated little blocks of binary 7094 instructions for the various operations in the expressions, threaded them together, and then ran the resulting program by calling it, just like a regular function."

Why wouldn't Scala/Clojure/Groovy et al be possible without JIT? It's possible to run on the JVM anyway, whether said VM supports JIT or not.

Java before JIT was added to the JVM was dead slow.

Java has a lot of great libraries for which there are not terrific examples in Python. Clojure gets all of them.

> Where does Python lack in text processing?

Clojure handles large strings better than Python (unless you start using substrings, in which case an underlying java bug hits you).

(oh, and Clojure is not a deliberately and comically crippled language).