My thought exactly. Actually I was think - "geez, these people are such hipsters". Everyone loves the "cool" languages - Scala, Haskell, etc. But of course the lame languages suck (Java). Though I was pleasantly surprised to see the love for C#. It's a very nice language and you'd think being from MS it wouldn't be "cool".
That's a dismissive attitude. I think the love shown to C# is example enough that there may be more to the results than hipster-ism. C# is great, and the vast majority of Java programmers are aware of that. I mean, holy shit - no lambadas? Lack of reified types? The Java ecosystem is amazing (build tools, libraries, the JVM, IDE's), but the language itself is depressingly stagnant and unpleasant to work with in comparison to similarly-placed languages.
But perhaps the cool languages of today are cool precisely because they offer real advantages. Maybe they're advantageous only in our unique historical moment. That has yet to be seen. If their popularity fades over time, that won't mean they were simply hipster fads. It could just as easily mean they met significant needs at one point in time, but the needs changed, or we developed better tools that met those same needs.
Yeah, that one perplexed me. I don't think anyone can deny Java's usefulness. I guess a lot of the hate is from people who find Java useful but still annoying. For my part, I don't think it's bad at all. When I use Java, I miss conveniences like `people.map { |p| [p.name, p.address] }`. But in exchange for typing more characters, Java gives me a huge ecosystem, good docs, effortless cross-platform coding, and pretty much the only hassle-free GUI API.
Maturity and longevity, mostly. For really serious projects, I prefer to mitigate my risk by picking something that's been mainstream for a long time and isn't likely to die off. I'm not saying Clojure, Scala, JRuby, etc. are going to die off. Just that it's too early to tell.
Also, it's not exactly the same ecosystem. Yes, you can use all the Java libraries. But the ecosystem also includes the dev environment/build system, the written material, and the peopleware associated with the language. You don't automatically import all of these from Java just because you're using the JVM.
Scala enables you to keep most of the Java ecosystem (API, docs, cross-platform, and swing is even nicer in scala), and you can do `people.map { p => (p.name, p.address) }`, granted that the IDEs have to get a plugin installed before they are as helpful, but both Eclipse and IntelliJ has awesome scala plugins.
I don't see so much hate in the current results for languages that offer few or no real advantages. It seems to me that most of the hate is directed at languages that are often mandated by external forces, whether those be bosses, target platforms or simply lack of alternatives within a niche.
What's the concern? Is there any reason why disliking a language for reasons of fashion is bad?
I personally think that I'd maybe prefer not to work with someone who likes (and argues) for languages due to fashion... but I'm also a by-day-and-night Haskell developer, so I imagine that invalidates my opinion in some ways.
Fashion-based-programming leads to endless re-invented wheels and more effort going into running round in circles than looking a bit into history and learning from it. Ruby and Python seem to live in parallel, separate worlds. Oh look, here comes Node.js where everything's written again, this time in JS.
I'm not arguing for monoculture but it's a bit sad to see isolated communities not working together.
Haskell is an example of a language which a good reason to exist: solid unique PL qualities and is also highly applicable to specific problems.
I like Ruby and have been programming heavily in it for the last year.
However I still think Java and C are really good languages. I appreciate the niceties of both strongly-typed compiled languages, along with the 'coolness' factor of the dynamic languages.
My biggest problem with VB was inconsistency. There were multiple flavors floating around with subtle incompatibilities, so you couldn't always reuse code without modifications. Also, it did some weird things with types. Like error messages along the lines of "Type mismatch: expected string, but got string."
If VB6/VBA weren't coupled to the god awful IDEs and completely unversionable/patchable binary formats of their applications, it would be a pretty decent programming language.
It's persisted - absurdly - in spite of those crippling issues.
The VB6 IDE was Ok for 1998, but 1998 was a long time ago.
I still use VB6/VBA to get shit done, but only because I have a bunch of code & tools I've already written in or for it. I can see how it would be pretty useless to most people.
Registry-free COM has solved all of the versioning issues for me.
Language-wise, I find it's limitations to be its strength - kind of like ouilipo for programming.
