This iteration of the RedMonk Programming Language Rankings is brought to you by Pivotal, the company behind Spring and Cloud Foundry. Join us in San Francisco for SpringOne Platform, a cloud-native event for the professional Java developer. Register here using the promo code S1P_RedMonk100 for $100 off your pass.

With a new and stable process for collecting the base metrics, it’s time to publish our Q3 Programming Language Rankings. 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 (Stack Overflow) and usage (GitHub) in an effort to extract insights into potential future adoption trends.

In January 2014 and again in January 2017, we were forced to make a change to the way that GitHub’s rankings were collected due to changes in the data’s availability. For more on these changes and the history of our rankings, see the summary from our last run. In the meantime, here’s how the rankings are performed currently.

Our Current Process

The data source used for these queries 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.)

The primary change is that the GitHub portion of the language ranking is now based on pull requests rather than repos. While this means we cannot replicate the rankings as they were prior to 2017, the results were generally correlated with our past runs and are the best method available. On the positive side, it also eliminates the most common complaint regarding the rankings historically: that measurements by repo might overestimate a given language’s importance – JavaScript, most frequently.

With that major update 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 2017.

(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). Note that this is actually a list of the Top 22 languages, not Top 20, because of said ties.

1 JavaScript
2 Java
3 Python
4 PHP
5 C#
6 C++
7 CSS
8 Ruby
9 C
10 Objective-C
11 Swift
12 Shell
12 Scala
14 R
15 Go
15 Perl
17 TypeScript
18 PowerShell
19 Haskell
20 CoffeeScript
20 Lua
20 Matlab

Following the update to our process entering 2017, what we most wanted to see in a subsequent run was stability. Because programming language adoption is a lagging indicator typically assessed by counting metrics, wild fluctuations are likely to be false indicators and over-responsive to actual market shifts which tend to be slower. In this, we were rewarded, because this quarter’s rankings show the expected modest amounts of change.

While the overall rates of change were minimal, as expected, this quarter’s run did feature a number of interesting moves both up and down the rankings, which we’ll discuss in a moment. Before then, it’s necessary to observe once again the remarkable staying power of JavaScript and Java atop the rankings. The former has lead the rankings as long as we’ve been doing them, and Java has never been lower than two. Rounding out the Top 5 are Python, PHP and C# which have at times traded places but are all languages with massive volume behind them. None of these languages moved in this ranking, but one tied for fifth did slip.

• C++: Dating back to our first runs of these rankings in 2012, C++ has always been a top ten language and had actually risen from seven to its high of a tie for fifth. This quarter, however, it dropped to sixth. In the bigger picture sense, this is not particularly meaningful, as C++ remains a tremendously widely used and discussed language and solidly in the top tier. It will be interesting to watch its trajectory, however, to see if the focus on systems languages with modern features such as Go begins to erodes any of this traction or if the language’s raw speed will continue to sustain a high level ranking.

• Ruby: Of the Tier 1 languages, Ruby has demonstrated perhaps the most movement in our history of ranking languages. Debuting at #5, it peaked at #4 in Q313 and fell to #6, bounced back to #5 and has since been steadily drifting downwards. This quarter’s ranking of #8 is the lowest for Ruby to date, and it’s reflective of the posts that appear every so often on Hacker News, Quora or other sources asking whether or not the language is dead. The good news for advocates of the language is that these questions date back years; the fact that they’re still being asked in 2017 can’t be considered good, precisely, but the fact that it remains a question might be. That being said, it’s unclear where a Ruby bounceback, if there is to be one, would come from. Swift and now Kotlin are the obvious choices for native mobile development, Go, Rust and others are clearer modern choices for infrastructure. The web, meanwhile, where Ruby really made its mark with Rails is now an aggressively competitive and crowded field. We’ll see if Ruby has another trick up its sleeve, but in the meantime, it can take solace in the fact that it remains tremendously popular.

• Powershell/Rust/Typescript: None of the three biggest improvements from the last rankings iteration – Powershell, Rust or Typescript – could replicate those gains, as all remained static. Which is understandable; in each case, the languages are entering a level of the rankings were material improvement is harder and harder to come by. They need only look at Go, which prior to Swift was the fastest growing language the rankings had seen, but has since stalled in the bottom half of the Top 20 rankings. Still, it will be interesting to see, particularly on the part of the two Microsoft languages, whether their increasingly popular tooling (VS.code) and dramatically shifting organizational reputation can lead to even greater heights.

• Scala: At this point last year, Scala was down to #14 on these rankings from a high of #12 as recently as 2013. In January, it jumped three spots into a tie at #11. This run, it slipped back to #12 leaving Swift in sole position of #11. In spite of the theoretical indignity of being ranked behind a language years its junior, #12 is an impressive performance for a language, and that is nearly as highly ranked as Scala has ever been. But the question facing Scala advocates and observers is whether or not this quarter’s decline is merely another blip, or the shape of things to come. As a JVM based language, Scala is no stranger to competition – besides Java itself, Scala is regularly compared and measured against Clojure and Groovy not to mention, depending on context, everything from Python to Go. It may be facing its stiffest test yet in the language we’ll discuss next, however, which is inspired by Scala but has the advantage of now having a major front end driver for adoption to complement its back end relevance.

• Kotlin: Generally speaking, we don’t spend much time discussing languages ranked #46 on our board. When Google chooses one to be a fully supported language on the most popular mobile platform in the world, however, we make exceptions. Kotlin’s numbers in our rankings are interesting, if premature. We snapshot data as of the first of June, which means Kotlin had exactly fifteen days to profit from its new role as Google’s alternative to Swift. That produced a bump from its last quarterly ranking, if a small one: in January, Kotlin was at #50, so it jumped a mere four spots, which on the surface seems unimpressive. Two things are interesting about the Kotlin numbers, however. First, the jump it made to get to #50. Kotlin spent the 2016 calendar year way down at #65 on our rankings; all of a sudden in January, it jumped 15 spots to #50. If you look at the Stack Overflow chart from our look at the language, it’s clear that the “low key buzz” Steve Yegge referred to was real and measurable (and, as an aside, will likely have us looking more closely at anomalous results down the rankings more closely in future). If we date not from Android’s decision, then, but from the early unannounced interest in the language, we’re looking at a 19 point jump. But just as interesting were the factors behind Kotlin’s #46 ranking: specifically, it was weighed down by Stack Overflow. Our GitHub rankings placed Kotlin 39th, but on Stack Overflow the language came in in 60th place. This is suggestive of people exploring and writing in Kotlin behind the scenes, but not discussing it much in public. It seems safe to assume that that ratio will change with Android developers worldwide increasingly looking at Kotlin for their applications moving forward. The big question facing Kotlin then isn’t whether it will experience gains based on interest – the language already has jumped nearly twenty spots in a year’s time which is very unusual – but how quickly, and to what degree. Are we looking at a Rust trajectory? A Go trajectory? Or, most exciting to advocates, one that looks like Swift? Kotlin’s already moving, but our January rankings should be fascinating to watch for Android’s new first tier language alone.

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.