Since I've been interested in how the Functional paradigm might help us developers deal with concurrency, there are 2 items here that really strike me:
1.) Clojure fell back
2.) Elixir, though small, is still moving forward
I've been a fan of Clojure since 2009. It grew rapidly for a few years, from 2009 till at least 2014. It has stalled out. This makes me sad because I've loved working with it and I think it a great community, in most ways. But it is true that the community has been unable to answer some of the criticisms leveled against it. The reliance on Emacs has meant it is not easy for beginners. On the other side, the elite (the purists?) have wanted to see Clojure be more like Scheme, or more like Racket, or more like Haskell. Clojure has offered up many interesting ideas, but perhaps hasn't quite built a complete eco-system that makes it broadly appealing.
Elixir, though very small, still seems to be moving forward, and perhaps has a chance to answer some of the demands that people made of Clojure (more pure? easier syntax?). Maybe Elixir is the language that make the Functional style the dominant style in computer programming?
A few (rambling) thoughts, as a long-time Clojure dev who's recently been focusing on Elixir.
The thing I like most about Elixir is the low friction between it and it's host language, Erlang. Erlang is a functional language right from the start, and the BEAM is designed to run a functional language, which means you never hit the weird FP-OO barrier that comes up so commonly in Clojure.
I really think the impedence mismatch between Clojure and the underlying Java implementation is a big, painful problem which is going mostly unacknowledged by the inner-core of the Clojure community. And that makes sense, because they're all (or mostly) "Java Guys" who are already sold on the Java ecosystem and are fine with there being a layer of spindly OO horror in their projects. They don't mind the Java layer poking through in unpleasant ways.
When I bring this up in a congregation of Clojurists I just get "shrug, welp, Clojure is a hosted language", not even an acknowledgement that there may be a problem worth discussing.
For the rest of us, the FP enthusiasts who don't have an emotional or professional attachment to Java, this sucks, because you can't do much in Clojure without also touching Java. As I said at the start of this ramble, Elixir/Erlang don't suffer from this problem, it's FP all the way down. Erlang idioms fit in with Elixir, and vice versa. No friction, no bullshit.
One final point: I think the Elixir team visibly care about ergonomics and good design, much more than the Clojure team seem to. Look at `mix` and compare it to `leiningen`, honestly. Look at Plug and Phoenix and compare to something like Luminus in Clojure-land. The difference is night-and-day. Look at how fast the `iex` repl boots up, or how fast the stop-compile-start workflow is in a Phoenix app. Even look at the content of the languages respective homepages (http://elixir-lang.org and http://clojure.org)
I also dropped Clojure/ClojureScript, even though it was my favorite language between 2012 and 2014/2015.
The main reason for me is the progression of Java and JavaScript during these years, which make ClojureScript less useful. ES6 has completely transformed the JavaScript development. I finally enjoy to code in JavaScript - this wasn't the case before. On the contrary, coding in ClojureScript became painful. It's difficult to follow the recent trends, to integrate new libraries without hassle. Currently I work on a project that use DraftJS. I don't want to know how to integrate it in ClojureScript ! It's a waste of time, and again the "joy of Clojure" still exists but is now less superior to the "joy of Javascript".
On the Clojure/JVM side, Java 8 is far from perfect but the lambdas expressions have made the language a bit less boring. I think many developer feel less the urge to leave Java for an alternative language. And if they really want it, there is Scala, still the best strong statically typed language on the JVM, and so, for me, still the best language for backend development.
In short, Clojure/ClojureScript was for me the best language for rapid prototyping and for front development. I've never really considered it for "serious" backend applications based on a complex data models, because of its dynamic typing. However, JavaScript development became much more pleasant, making ClojureScript less attractive, less differentiating. I believe that today, you have to be a true Clojure fan to code in ClojureScript.
I don't feel like clojure stalled out. You have to realize the redmonk rankings are using very weak heuristics to get these results. I'd rather choose languages and tools by how much they match the problem space rather than how popular they are at any particular point in time.
If you trim out all the worthless SO questions/anwsers you'll get radically different rankings on redmonk. JavaScript could very easily drop from its first place doing just that.
I don't get why people chase popularity in programming languages. That's what you do in a pop culture, not in an engineering one.
I will be blunt and state that neither of them matter.
Some people might hate Java and search for alternatives on the JVM, but 90% of the production code on the JVM, its commercial variants, and Android is plain Java.
Also ClojureScript is not 100% Clojure and most web shops across the world only care about JavaScript.
Likewise, the majority of developers targeting BEAM will be using Erlang.
If something I learned from my Turbo Pascal/Delphi, Oberon experience, is that programming languages that aren't considered a first class experience from the platform owners never manage to get a significant market share, long term.
I am not sure why Clojure is "stagnating". I don't think it's about Emacs, we have Cursive now which is very powerful and runs on top of IntelliJ. Clojure also is picking up in webdev. A new book just came out from Sotnikov, Arachne was announced recently, Om is being worked on, couple of different screencast series are being made, etc. I am not a seasoned developer but I like Clojure and I am sticking with it because it makes sense to me. I think it's an awesome language and I wish more people would try it and develop in it.
Elixir's doing very well for its age—before 1.0 it had four books, a conference, and a dedicated video series. With the rise of Phoenix there's quite a lot mire of resources for it.
Clojure (and ClojureScript via Reagent[1]) is what got me into functional programming in the first place. However, as a developer working in a .NET shop I found more opportunities (e.g. .NET interop) to do "functional programming" in F#, which has also been well support cross-platform for some time.
At the time, Leiningen was still in its infancy and I hit a lot of issues getting things running but when I finally did the language had a profound impact on me as a developer.
I think ClojureScript could benefit my team as both a productivity and performance boost. But convincing a large team to switch to a lisp is pretty much never going to happen. I might as well try to get everyone to switch to dvorak keyboards while I'm at it.
Clojure worked for me until I started to do parallel programming. I tried to use core.async but immediately found that I'm using two distinct style of programming, and code reuse became a serious problem.
I didn't find any resources on how other Clojure programmers deal with this problem, but this eventually lead me to drop Clojure and Clojurescript, and use Elixir and Elm instead.
I don't think it matters much what these charts say as long as they do not measure merit and Clojure has a lot of it. You can use it irrespective of how an ill-advised majority of developers think Javascript/Node/Angular is good.
Regarding the reliance on Emacs, might not be the case anymore. When I was new to Clojure, I immediately used an IntelliJ plugin called Cursive. It was/is great, same experience as writing Java in IntelliJ. (https://cursive-ide.com/)
Full time Clojure dev here who has been transitioning to non-Clojure projects recently, for two main reaons:
1) I've decided that static typing is the world I want to program in, for a wide range of reasons.
2) The JVM (and JS) have their limits, and Clojure is just not as portable as I'd prefer.
Otherwise, I learned a lot from working with Clojure over many hundreds of programming hours, and it is an impressive feat of engineering, but it's limitations are insurmountable at this point.
I guess the patronizing and uncooperative attitude towards the community plays its part. If you don't accept Rich Hickey and Relevance / Cognitect / whatever they call themselves nowadays as the ultimate source of wisdom, your opinion is worthless and you're "Doing It Wrong™".
But on the other hand, they're very much keeping the tradition of the of the Smug Lisp Weenie alive, albeit as a caricature rather than a rebirth.
Regarding FP: My daughter is a (non CS STEM) student at UC. She knows one language: "R". (I tried to get her to learn Python in high school, but it never took)
While R is certainly not a general purpose language (yet?), it is very much an FP type language, and gaining in popularity. I have only tinkered with it a little, but it looked pretty sound.
When looking at github-provided data it doesn't make sense to differ between C++, C and Objective-C/C++ since the detection for these languages is still completely broken. For instance this project doesn't have a single line of Objective-C in it, yet github says there's 9% Obj-C in it: https://github.com/floooh/yakc. Similar oddities in my other C++ projects.
I have a bunch of repositories written in pure C (no C++) with a few Makefiles and some supporting shell scripts. When I google my name, the result from GitHub has the following description:
"my_username has X repositories written in Shell, Makefile, C++, and C. Follow their code on GitHub."
Hmm...I wish they had taken a bit more time to dig into the situation with Julia than simply to note it moved from position 51 to 52 on the ranking (is that even a significant shift?). Having just come from giving a presentation at this year's JuliaCon, I am more optimistic about Julia's future than at any point in the past. I think what we're seeing here is that Julia is making a concerted push toward v1.0. It was announced at JuliaCon 2016 that they are targeting JuliaCon 2017 for the v1.0 release. It should be expected, then, that the break-neck pace of innovation has taken a back seat to a focus on stability, but based on what is already on the roadmap for Julia v2.0, I don't see Julia moving anywhere but up.
(Also, I think the comparison to CoffeeScript is rather unfortunate. In my mind, CoffeeScript was primarily addressing shortcomings in JS that JS has, since, done quite a bit to rectify. Julia is not trying to be a better "X", so there's no "X" to steal away its momentum.)
This is sample selection bias. Cavorting with converts at their conference is always going to lead to a temporary afterglow of bullishness and says nothing about adoption rates.
Setting aside the specific Julia functional merit questions, the answer is that in general, no, the difference between 51 and 52 is not particularly significant.
That being said, the macro perspective - in which Julia is growing more slowly than other languages, or arguably not at all - is relevant for those wishing to see more adoption.
"GitHub language rankings are based on raw lines of code, which means that repositories written in a given language that include a greater amount of code in a second language (e.g. JavaScript) will be read as the latter rather than the former."
This has huge impact on the ranking - it does not seem right to me..
AFAICT (based on years of poking around various projects, and based on the data they provide on my own projects), the data provided by GitHub are largely broken.
Making analyses and comments on these data is futile, as I have already argued directly (and with vigour on my side) with several Redmonk employees in the past. This didn't end well, since I'm pretty passionate about these things in particular, and "the truth" in general (vs. "opinions").
I'm sure real scientists could do some interesting work on this subject, but Redmonk's methodology is anything but scientific, and in consequence, their results are just content marketing, not something that you should base business or engineering decisions upon.
I love this ranking because while all rankings have flaws, this at least is very transparent on how it works, it's parsimonious, it is entirely numerical, easily reproducible, and it gives us at least a small amount of cross validation via two (mostly) orthogonal variables. Now all we need to do is to animate the plot over time.....
I know right? The fact that the metric makes absolute sense is beautiful. Yes it probably misses out on a ton of factors that contribute to ranking (see TIOBE index metrics) but the transparency and simplicity of it all make up for it. You can directly see how each metric is contributing to the factor and the numbers are very easily verifiable.
That is certainly true but I wonder if this effect is exaggerated by the methodology of this study.
If they simply count existing lines of code/SO questions and none of those ever get deleted, then inertia is bound to increase.
The more old lines of code/questions there are, the longer it takes for any new language to rise in the rankings, even if the new language is used for all new code.
But I don't know enough about the methodology of this study. Maybe they are doing something against this statistical incumbency effect.
That reasoning is plausible, but a large portion of their longevity could easily be due to network effects (libraries + legacy code) and nothing to do with the quality of the languages.
Well is there really any incentive to change? Code is just a method of communication with the computer, just like language is. Sure a country like France could move over to speaking English instead of French and probably be a little better off for it, but fundamentally, French gets the job done just fine. There's too much inertia to change amongst established companies I think.
Maybe it was around about the time Microsoft started adding git support to their Visual products? (I don't know, as I don't really use any Microsoft products, but I know Microsoft did embrace git and a lot of OSS tech over the past few years.)
Misleading title. It's entirely github and SO-centric and as such misrepresents C and probably C++ as well, since those languages have scads of code elsewhere.
Unrelated but still annoying. This website is a prime example of responsive design gone wrong. Trying to read it on an iphone, but the chart with the trends overflows out of the screen, and the website locked the ability to zoom out.
In this example as often, the website would be more readable without responsive design.
TeX has its own stackexchange site [0], and so does Emacs [1].
While both TeX and Emacs Lisp questions are still treated on StackOverflow, it probably explains why TeX in particular appears to be such an outlier. (It's sure not because people aren't having trouble with it. The stackexchange site is indispensable.)
Dart held static at 37, which leaves it 11 spots behind TypeScript. We have seen very little movement in the language generally, and it hasn't really gotten any notable boosts from outside drivers.
> There is no movement, in fact, among languages ranked within our Top 10.
> the difficulty of growth is proportional to the rankings themselves – as one rises, so does the other.
OF COURSE this will be the case when your analysis is looking at total cumulative usage instead of current usage (i.e. deltas in cumulative usage)!
For example, say language X has been around 20 years, and language Y 5. Language Y could be 10 times more popular than language X today, but if the analysis is counting 20 years of accumulated code in X, X will easily rank higher.
I hunted for their methodology, and found none. Nothing they say indicates they are doing delta analysis. Since such analysis would not be trivial and be a lot more expensive, I'm pretty sure they'd mention it if they were doing it.
To corroborate my criticism, the TIOBE Index, which measures signals where accumulation is less a factor, shows much more movement over time, with languages rising and falling as one would expect: http://www.tiobe.com/tiobe_index.
[+] [-] lkrubner|9 years ago|reply
1.) Clojure fell back
2.) Elixir, though small, is still moving forward
I've been a fan of Clojure since 2009. It grew rapidly for a few years, from 2009 till at least 2014. It has stalled out. This makes me sad because I've loved working with it and I think it a great community, in most ways. But it is true that the community has been unable to answer some of the criticisms leveled against it. The reliance on Emacs has meant it is not easy for beginners. On the other side, the elite (the purists?) have wanted to see Clojure be more like Scheme, or more like Racket, or more like Haskell. Clojure has offered up many interesting ideas, but perhaps hasn't quite built a complete eco-system that makes it broadly appealing.
Elixir, though very small, still seems to be moving forward, and perhaps has a chance to answer some of the demands that people made of Clojure (more pure? easier syntax?). Maybe Elixir is the language that make the Functional style the dominant style in computer programming?
[+] [-] s_kilk|9 years ago|reply
The thing I like most about Elixir is the low friction between it and it's host language, Erlang. Erlang is a functional language right from the start, and the BEAM is designed to run a functional language, which means you never hit the weird FP-OO barrier that comes up so commonly in Clojure.
I really think the impedence mismatch between Clojure and the underlying Java implementation is a big, painful problem which is going mostly unacknowledged by the inner-core of the Clojure community. And that makes sense, because they're all (or mostly) "Java Guys" who are already sold on the Java ecosystem and are fine with there being a layer of spindly OO horror in their projects. They don't mind the Java layer poking through in unpleasant ways.
When I bring this up in a congregation of Clojurists I just get "shrug, welp, Clojure is a hosted language", not even an acknowledgement that there may be a problem worth discussing.
For the rest of us, the FP enthusiasts who don't have an emotional or professional attachment to Java, this sucks, because you can't do much in Clojure without also touching Java. As I said at the start of this ramble, Elixir/Erlang don't suffer from this problem, it's FP all the way down. Erlang idioms fit in with Elixir, and vice versa. No friction, no bullshit.
One final point: I think the Elixir team visibly care about ergonomics and good design, much more than the Clojure team seem to. Look at `mix` and compare it to `leiningen`, honestly. Look at Plug and Phoenix and compare to something like Luminus in Clojure-land. The difference is night-and-day. Look at how fast the `iex` repl boots up, or how fast the stop-compile-start workflow is in a Phoenix app. Even look at the content of the languages respective homepages (http://elixir-lang.org and http://clojure.org)
[+] [-] megalomanu|9 years ago|reply
On the Clojure/JVM side, Java 8 is far from perfect but the lambdas expressions have made the language a bit less boring. I think many developer feel less the urge to leave Java for an alternative language. And if they really want it, there is Scala, still the best strong statically typed language on the JVM, and so, for me, still the best language for backend development.
In short, Clojure/ClojureScript was for me the best language for rapid prototyping and for front development. I've never really considered it for "serious" backend applications based on a complex data models, because of its dynamic typing. However, JavaScript development became much more pleasant, making ClojureScript less attractive, less differentiating. I believe that today, you have to be a true Clojure fan to code in ClojureScript.
[+] [-] jeremiep|9 years ago|reply
If you trim out all the worthless SO questions/anwsers you'll get radically different rankings on redmonk. JavaScript could very easily drop from its first place doing just that.
I don't get why people chase popularity in programming languages. That's what you do in a pop culture, not in an engineering one.
[+] [-] pjmlp|9 years ago|reply
Some people might hate Java and search for alternatives on the JVM, but 90% of the production code on the JVM, its commercial variants, and Android is plain Java.
Also ClojureScript is not 100% Clojure and most web shops across the world only care about JavaScript.
Likewise, the majority of developers targeting BEAM will be using Erlang.
If something I learned from my Turbo Pascal/Delphi, Oberon experience, is that programming languages that aren't considered a first class experience from the platform owners never manage to get a significant market share, long term.
[+] [-] fierycatnet|9 years ago|reply
[+] [-] sotojuan|9 years ago|reply
[+] [-] marpstar|9 years ago|reply
At the time, Leiningen was still in its infancy and I hit a lot of issues getting things running but when I finally did the language had a profound impact on me as a developer.
[1]: https://reagent-project.github.io
[+] [-] city41|9 years ago|reply
[+] [-] sorpaas|9 years ago|reply
I didn't find any resources on how other Clojure programmers deal with this problem, but this eventually lead me to drop Clojure and Clojurescript, and use Elixir and Elm instead.
[+] [-] davidgrenier|9 years ago|reply
[+] [-] airplane|9 years ago|reply
[+] [-] hellofunk|9 years ago|reply
1) I've decided that static typing is the world I want to program in, for a wide range of reasons.
2) The JVM (and JS) have their limits, and Clojure is just not as portable as I'd prefer.
Otherwise, I learned a lot from working with Clojure over many hundreds of programming hours, and it is an impressive feat of engineering, but it's limitations are insurmountable at this point.
[+] [-] _pmf_|9 years ago|reply
I guess the patronizing and uncooperative attitude towards the community plays its part. If you don't accept Rich Hickey and Relevance / Cognitect / whatever they call themselves nowadays as the ultimate source of wisdom, your opinion is worthless and you're "Doing It Wrong™".
But on the other hand, they're very much keeping the tradition of the of the Smug Lisp Weenie alive, albeit as a caricature rather than a rebirth.
[+] [-] Roboprog|9 years ago|reply
While R is certainly not a general purpose language (yet?), it is very much an FP type language, and gaining in popularity. I have only tinkered with it a little, but it looked pretty sound.
[+] [-] flohofwoe|9 years ago|reply
[+] [-] bluetomcat|9 years ago|reply
"my_username has X repositories written in Shell, Makefile, C++, and C. Follow their code on GitHub."
[+] [-] acangiano|9 years ago|reply
The trouble is that I make this statement from a place of intuition, conscious of my own biases, so I could be wrong.
[+] [-] jballanc|9 years ago|reply
(Also, I think the comparison to CoffeeScript is rather unfortunate. In my mind, CoffeeScript was primarily addressing shortcomings in JS that JS has, since, done quite a bit to rectify. Julia is not trying to be a better "X", so there's no "X" to steal away its momentum.)
[+] [-] vegabook|9 years ago|reply
[+] [-] tanlermin|9 years ago|reply
[+] [-] sogrady|9 years ago|reply
That being said, the macro perspective - in which Julia is growing more slowly than other languages, or arguably not at all - is relevant for those wishing to see more adoption.
[+] [-] machbio|9 years ago|reply
This has huge impact on the ranking - it does not seem right to me..
[+] [-] fermigier|9 years ago|reply
Making analyses and comments on these data is futile, as I have already argued directly (and with vigour on my side) with several Redmonk employees in the past. This didn't end well, since I'm pretty passionate about these things in particular, and "the truth" in general (vs. "opinions").
I'm sure real scientists could do some interesting work on this subject, but Redmonk's methodology is anything but scientific, and in consequence, their results are just content marketing, not something that you should base business or engineering decisions upon.
[+] [-] vegabook|9 years ago|reply
[+] [-] xerophyte12932|9 years ago|reply
[+] [-] SwellJoe|9 years ago|reply
[+] [-] fauigerzigerk|9 years ago|reply
If they simply count existing lines of code/SO questions and none of those ever get deleted, then inertia is bound to increase.
The more old lines of code/questions there are, the longer it takes for any new language to rise in the rankings, even if the new language is used for all new code.
But I don't know enough about the methodology of this study. Maybe they are doing something against this statistical incumbency effect.
[+] [-] sergiotapia|9 years ago|reply
2. Talent pool in said languages.
[+] [-] nhaliday|9 years ago|reply
[+] [-] terda12|9 years ago|reply
[+] [-] adamnemecek|9 years ago|reply
[+] [-] flukus|9 years ago|reply
I'm guessing that VB uptick was from VB devs finally discovering git?
[+] [-] SwellJoe|9 years ago|reply
[+] [-] na85|9 years ago|reply
[+] [-] cm2187|9 years ago|reply
In this example as often, the website would be more readable without responsive design.
[+] [-] pieterr|9 years ago|reply
[+] [-] rezashirazian|9 years ago|reply
[+] [-] gavinpc|9 years ago|reply
While both TeX and Emacs Lisp questions are still treated on StackOverflow, it probably explains why TeX in particular appears to be such an outlier. (It's sure not because people aren't having trouble with it. The stackexchange site is indispensable.)
[0] http://tex.stackexchange.com/
[1] http://emacs.stackexchange.com/
[+] [-] munyari|9 years ago|reply
[+] [-] insulanian|9 years ago|reply
[+] [-] themihai|9 years ago|reply
[+] [-] unknown|9 years ago|reply
[deleted]
[+] [-] asdfzxc|9 years ago|reply
[+] [-] jmnicolas|9 years ago|reply
[+] [-] pjmlp|9 years ago|reply
When Google own teams rather use Typescript, it speaks a lot about it.
[+] [-] sogrady|9 years ago|reply
[+] [-] elchief|9 years ago|reply
[deleted]
[+] [-] eevilspock|9 years ago|reply
> the difficulty of growth is proportional to the rankings themselves – as one rises, so does the other.
OF COURSE this will be the case when your analysis is looking at total cumulative usage instead of current usage (i.e. deltas in cumulative usage)!
For example, say language X has been around 20 years, and language Y 5. Language Y could be 10 times more popular than language X today, but if the analysis is counting 20 years of accumulated code in X, X will easily rank higher.
I hunted for their methodology, and found none. Nothing they say indicates they are doing delta analysis. Since such analysis would not be trivial and be a lot more expensive, I'm pretty sure they'd mention it if they were doing it.
To corroborate my criticism, the TIOBE Index, which measures signals where accumulation is less a factor, shows much more movement over time, with languages rising and falling as one would expect: http://www.tiobe.com/tiobe_index.
[+] [-] 0xmohit|9 years ago|reply