The RedMonk Programming Language Rankings: June 2018

Share via Twitter Share via Facebook Share via Linkedin Share via Reddit

They’re a month overdue, and from the volume of inbound questions about when the language rankings would drop, it’s been noticed. As always, these are a continuation of the work originally performed by Drew Conway and John Myles White late in 2010. While the means of collection has changed, the basic process remains the same: we extract language rankings from GitHub and Stack Overflow, and combine them for a ranking that attempts to reflect both code (GitHub) and discussion (Stack Overflow) traction. The idea is not to offer a statistically valid representation of current usage, but rather to correlate language discussion and usage in an effort to extract insights into potential future adoption trends.

Our Current Process

The data source used for the GitHub portion of the analysis is the GitHub Archive. We query languages by pull request in a manner similar to the one GitHub used to assemble the 2016 State of the Octoverse. Our query is designed to be as comparable as possible to the previous process.

  • Language is based on the base repository language. While this continues to have the caveats outlined below, it does have the benefit of cohesion with our previous methodology.
  • We exclude forked repos.
  • We use the aggregated history to determine ranking (though based on the table structure changes this can no longer be accomplished via a single query.)

For Stack Overflow, we simply collect the required metrics using their useful data explorer tool.

With that description out of the way, please keep in mind the other usual caveats.

  • To be included in this analysis, a language must be observable within both GitHub and Stack Overflow.
  • No claims are made here that these rankings are representative of general usage more broadly. They are nothing more or less than an examination of the correlation between two populations we believe to be predictive of future use, hence their value.
  • There are many potential communities that could be surveyed for this analysis. GitHub and Stack Overflow are used here first because of their size and second because of their public exposure of the data necessary for the analysis. We encourage, however, interested parties to perform their own analyses using other sources.
  • All numerical rankings should be taken with a grain of salt. We rank by numbers here strictly for the sake of interest. In general, the numerical ranking is substantially less relevant than the language’s tier or grouping. In many cases, one spot on the list is not distinguishable from the next. The separation between language tiers on the plot, however, is generally representative of substantial differences in relative popularity.
  • In addition, the further down the rankings one goes, the less data available to rank languages by. Beyond the top tiers of languages, depending on the snapshot, the amount of data to assess is minute, and the actual placement of languages becomes less reliable the further down the list one proceeds.

With that, here is the third quarter plot for 2018.*

(Click to embiggen)

Besides the above plot, which can be difficult to parse even at full size, we offer the following numerical rankings. As will be observed, this run produced several ties which are reflected below (they are listed out here alphabetically rather than consolidated as ties because the latter approach led to misunderstandings).

1 JavaScript
2 Java
3 Python
5 C#
6 C++
8 Ruby
9 C
9 Objective-C
11 Swift
12 Scala
12 Shell
14 Go
14 R
16 TypeScript
17 PowerShell
18 Perl
19 Haskell
20 Lua

As always, the consistent performance of our Tier 1 languages – the top ten, more or less – is at once surprising and unsurprising. The relatively static nature of the top ten languages is interesting, certainly, in a technology landscape that is best characterized as heavily fragmented and growing more so at an accelerating rate. Conversely, however, it’s important to note that the numbers measured are accretive, and as with financial metrics, rates of growth are fastest when projects are new and harder and harder to come by over time. New language entrants are behind from the day they are released, in other words, which makes displacing the most popular languages a significant and uphill battle.

In our Top Ten, then, with one exception which we’ll come to, there is little to note. Outside of the top tier, however, there are several changes worth discussing. Unusually, in fact, there’s something of a unifying theme to the various changes in this run: retrenchment.

  • Kotlin (-1), Scala (2), Clojure (4), Groovy (2): In general, we caution readers not to assign too much weight to small changes in the rankings; the differences between one spot or another, in general, tend to be slight. This remains true as we look at the case of the JVM languages. It is interesting, however, that there is something of a pattern to the changes in this quarter’s run, however slight the changes may be. To refresh, the conventional wisdom around Kotlin has been that between its clean, modern design (one that inspired Swift) and its elevation to first class citizen status on Android that it’s the non-Java JVM language to beat. Its performance within these rankings has done little to discourage this notion; apart from Swift, it’s the fastest growing language we’ve seen. But for this quarter at least, Kotlin’s JVM based competitors managed to turn back the clock. Kotlin took a minor step back from 27th to 28th, while its JVM counterparts Scala (12), Clojure (21) and Groovy (21) all showed bounces – some significant. This was notable for Scala in particular, as it had dropped for three consecutive quarters entering this run. What this means for the future has yet to be determined, and Kotlin’s future remains bright, but its triumphant ascendance will have to wait for another quarter.

  • Julia (3): A week or so ago, we received the following inquiry from a large vendor: “what are your thoughts on Julia – is it going to remain a niche language or grow or die?” The inquiry was interesting, both because of where it came from and because we haven’t had anybody ask about Julia in some time. While it’s been written up here before, it has tended to move very slowly and thus hasn’t attracted much attention. But the inquiry was well timed, because according to our rankings Julia is making slow but steady progress. This quarter Julia jumped three spots to 36, which is its fourth consecutive quarter of growth (36, 39, 40, 52). It’s certainly not on a Kotlin or Swift path, and the esoteric nature of the language may yet relegate it to niche status, but its steady performance has put it back on the map as one to watch.

  • R (-2): R is essentially a case study at this point for why we recommend against over-reacting to any particular quarter’s performance. R has dropped two spots previously, only to bounce back a quarter or two later. Its domain specific nature means that it is never likely to compete for the very top spots on this ranking, but it remains dominant and broadly used within its area of expertise.

  • Rust (0): Having jumped three spots in the last edition of these rankings and being the subject of much discussion in programming language communities, the question for Rust in Q3 was whether it could continue its upward trajectory into the Top 20. For the short term, at least, the answer is no, as the headwinds kept Rust at #23 for the second consecutive quarter. This quantitative stall is to some degree unsurprising, because growth becomes increasingly difficult the higher up a language ascends in the rankings. Anecdotally, however, Rust is popping up with increasing frequency, and long term it will be interesting to see what if any benefits it has from the language’s usage by open source projects originating in China such as PingCAP’s TiDB.

  • Swift (-1), Objective C (+1): The only change within our Top 10 languages this quarter was Swift’s demotion from a tie with Objective C back to the 11th spot on our list. This has the consequence of boosting Objective C from a tie for 10th to outright 9th place. This may seem consequential, but the reality is that the difference in their collective rankings, while measurable, is slight. While it has yet to break in to the Top 10 and stay there, Swift’s adoption and usage remains robust. If or when it is ever established as a server side language as IBM and others have attempted to push at times, its ceiling is virtually unlimited.

  • Go (2), TypeScript (-2): As with Kotlin, we’re regularly asked about TypeScript and its rapid growth. In keeping with the overall theme this quarter of retrenchment, however, TypeScript dropped for the first time in several quarters. It was a mere two spot slide, and the language remains enormously popular at 16th on our rankings, but it was notable nonetheless. After a one quarter single point drop, Go bounced back, essentially trading places with TypeScript at #14. While the languages are quite distinct in where and how they are used, it will be interesting to see how these languages perform relative to one another moving forward given that they seem to occupy relatively the same spots on the rankings with frequency.

Credit: My colleague Rachel Stephens evaluated the available options for extracting rankings from GitHub data, and wrote and executed the queries that are responsible for the GitHub axis in these rankings. She is also responsible for the query design and collection for the Stack Overflow data.

  • The original version of this chart had the axes reversed; this has been fixed and the image updated. Thanks to Edgar Arenas for the tip.


  1. Are the axes/labels mixed up?

    Last time languages positions where more or less diagonally opposed

    1. Edgar: well done for noticing that; the axes were indeed reversed. the image has been updated and re-uploaded. thanks for letting us know.

  2. Clojure folks don’t even ask questions on stackowerflow anymore, because there are so many other options, like clojureverse, clojurians slack channel, r/clojure, clojure on discord., purely functional forums, etc…

    1. Same with TeX, Mathematica, etc. The problem is that we cannot have a separate query process for a hundred different languages. The best we can do is the process used here, imperfect though it may be.

Leave a Reply

Your email address will not be published. Required fields are marked *