Comment by llambda | Hacker News Reader

Comment by llambda | Hacker News Reader

As anecdotal/non-scientific polling and researching, this is certainly interesting. Perhaps the big take away for me is the OP's note that the JVM rather than CLR has become a big target for emergent languages where a few years ago CLR was billed as the future of cross platform endeavors. (Note that at least one of the Big Three, Clojure, now also targets CLR in a branched project.)

Slightly disappointing is the fact that while Clojure scores highly among developers it doesn't seem to have made a proportionally large impact on the commercial space. However it's important to note that the OP only draws these conclusions from one source, Indeed.com, and I have to wonder how representative this is of the kinds of companies that might be hiring for Clojure related jobs: in other words, would they be on Indeed.com's radar at all?

Finally, can we really draw any significant conclusions from these non-scientific points? Probably not, but it is interesting to wonder: there seems to be a good deal of momentum behind the JVM at this point and it will be an interesting, exciting future if Groovy/Scala/Clojure become leading languages. (Even more interesting is the prospect that they might all end up being leading languages...)

Very interesting languages are being built for both the CLR and JVM. On the JVM the main ones I know of are Scala, Clojure and Kotlin. I think ClojureScript deserves mention even if a dialect due to the thoughts it allows one to think more easily (LightTable).

The CLR also has lots of very interesting languages under development. Languages like F# and Nemerle. Microsoft Research also pump out cutting edge stuff like the dependently typed F* (http://research.microsoft.com/en-us/projects/fstar/) and in language support for probabilistic programming http://research.microsoft.com/en-us/projects/fun/. The problem with MSR stuff is that their licences are so cumbersome and restrictive.

ClojureScript doesn't run on either the CLR or JVM; the compiler is JVM-based Clojure but the output runs as JS. And it's worth noting that Scala, Clojure, and Kotlin all originated outside of Sun; where F# originated from inside Microsoft.

Yes, that's why I made a note of its dialect nature. But I still count it as something that sprung from interesting work in the JVM community that deserves to be noticed on its own. In this case, the output as javascript is almost incidental, the more interesting results is the language-browser interaction it allows.

It does not matter where the research got done as long as it's interesting and moves things forward. Anyways, the cultures of MS and MSR are so different, it is arguable if one can even consider MSR as part of Microsoft. Sort of like Hong Kong and China. MSR fund a lot of haskell work for example.

Actually, ClojureScript worked just fine in Rhino, JS implementation that ships with the JDK, last time I checked.

Fantom has had support for the JVM and the CLR since it first came out. It has subsequently added JavaScript as an output language.

I've been wondering why Fantom doesn't seem to get the respect or play that some of these others have. Is it because it courts both camps, so neither wants to use it? It's a neat language, although perhaps not very revolutionary compared to these.

Microsoft and the Mono Project have both doubled down on C# as their language of choice for the CLR. Rather than really push for greater adoption of F#, it seems that they're letting F# incubate functional programming concepts, which later trickle down into C# for more mainstream developers.

Looking at the JVM, it seems like a similar dichotomy is happening with Scala, although more slowly without a Microsoft-like corporate shepherd.

Java and Groovy still have the mainstream developers' attention, but Scala is slowly growing mindshare. Clojure, much like F#, still seems to remain in the realm of the hobbyists and early early adopters.

My feeling is that C# as a language is getting close to being full of features. Microsoft have done a really good job of adding things to it so far without turning it into a hodge-podge, but if they keep going at the same rate then it seems inevitable that they'll either have to let it get messy or do a big redesign.

I'd agree with this, but I think the reason that more .NET developers don't revolt is because there seems to be limited uptick on some of the newer features.

E.g., generics were introduced in .NET 2.0 around 2005, but it was very common to find .NET shops where you didn't see them used in the code even as late as 2009. Same goes for Lambdas in .NET 3.5, and Dynamic objects in .NET 4.0. The corporate install base just tends to be more conservative with picking up new language features.

I think it's more likely that a big redesign will come and a new language will get introduced in a few years.

Honest question: Do you get the sense that the type of programmer who really likes .NET is one that goes for "alternate" languages? I've had limited exposure, but I do not get this sense; rather, the ".NET guys" I've been around fall into 2 basic camps: 1) They want to just do the minimal problem solving required for their role and don't really care about technology for the sake of it, and 2) They have bought into the MS ecosystem, and will just go with that flow.

Basically, they're not hobbyist or "I code because I love to" types; which are the (IMO) more curious and invest time in new things, just because.

I think that's a fair assessment, and it's one of the reasons I left .NET about a year ago.

The average .NET developer usually works in a 9-5 corporate environment that is completely bought into the MS ecosystem. This environment has traditionally been very opposed to Open Source and discourages hobbyist programmers as a result.

There are hobbyists and "I love to code" types in the .NET community (many will likely jump into this HN thread) but there are comparatively fewer hobbyists in the .NET community when compared to other communities.

It doesn't matter if the CLR is supposed to be the future of cross-platform languages. It is irrevocably tainted by Microsofts primary focus on the windows platform.

A new language is extremely vulnerable, more so that properly anything on earth, and its chances of adoption are exeendingly rare. You just cannot afford to cut of the couple of hundred early users because your language only works, or works best, on Windows.

Clojure is 4-5 years younger than Groovy and Scala.

If someone could find me some scientific data on usage (I've been working on this for a while with other languages) I would love it. Seems we will always be stuck with "non-scientific," volunteered information.

Reply on news.ycombinator.com