This iteration of the RedMonk Programming Language Rankings is brought to you by YLD. Experts in custom software development and pioneers in cutting edge technologies (Node, React); we enable you to innovate and stay ahead of the competition. Get in touch.

Given that we’re into March, it seems like a reasonable time to publish our Q1 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 and usage 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.

We also had one other minor change for this run. Historically, our Stack Overflow tag counts have been collected direct from the source – stackoverflow.com. While this was the initial collection process, the spreadsheet containing our January 2018 tag counts became corrupted and unusable. With a helpful pointer from Stack Overflow itself, however, we were able to collect the required metrics using their useful data explorer tool. The results differed slightly from the website, but not materially as far as we can tell, but bear that it mind as a potential influence.

With those updates 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 first 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
4 PHP
5 C#
6 C++
7 CSS
8 Ruby
9 C
10 Swift
10 Objective-C
12 Shell
12 R
14 TypeScript
14 Scala
16 Go
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 not by the high level of change but the increasing pace of same. 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.

• Go (-1): Since it burst onto the scene a little less than a decade ago, Go has been one of the fastest growing languages we’ve seen this side of Swift. Very few other languages have been able to vault themselves into the Top 20 as quickly as Go, a testament to its rock solid reputation as a back end systems language. That reputation notwithstanding, however, the evidence suggests that Go may have plateaued. After holding steady at 15 for two quarters, Go has watched Swift leapfrog it and for the first time in our rankings, actually fell off a spot down to #16. To be clear, we don’t recommend reading too much into the difference between one spot or another, even at the top of the rankings, but the trajectory doesn’t give much hope that Go will resume its rapid upward climb anytime soon. Nor does the language itself; while its reputation as a back end language is unquestioned, it lacks the versatility of comparable languages like Java that would grant it access to new markets and thus new growth.

• Kotlin: As we noted in our last run, the combination of Kotlin’s attractiveness to Java developers and its elevation to first class citizen on the Android platform seemed to indicate the language was poised for a major jump. In the course of little more than a year, Kotlin has gone from #65 to #46 in our Q3 run to #27 as of January. It didn’t quite match the performance of Swift, which managed a #68 to #22 jump in half that time, but Kotlin is now the second fastest growing language we have seen after Apple’s successor to Objective-C. Interestingly, the two languages have taken distinctively different paths to their respective rankings. Swift got its rankings largely through outperforming on the Stack Overflow axis of our rankings. This is the exact inverse of Kotlin, which performs well on GitHub, but whose relative community traction outside of Stack Overflow under-represents the language on that axis. Either way, Kotlin is one of the fastest growing languages in the world at present, and for good reason. What will be particularly interesting to watch is whether Kotlin can achieve a foothold in mainstream enterprise applications. This would give it an avenue for growth that Swift lacks at present.

• Powershell (+1) / R (+2) / TypeScript (+3): Of all of the vendors represented on this list, Microsoft has by a fair margin the most to crow about. Its ops-oriented language Powershell continues its steady rise, and R had a bounceback from earlier slight declines. TypeScript, meanwhile, pulled off a contextually impressive three spot jump from #17 to #14. Given that growth in the top twenty comes at a premium, hitting the ranking that a widespread language like R enjoyed in our last rankings is an impressive achievement. From a macro perspective, it’s also worth noting that Microsoft is seeing growth across three distinct categories in operations, analytics/data science and application development. More on this later, but it’s a strong indication that Microsoft’s multi-language approach to the broader market is paying dividends.

• Rust (+3): The tortoise to Go’s original hare, Rust has continued its slow and steady ascent, checking in just inside the Top 25 for the first time at #23. This makes it more popular in these rankings than Clojure, Groovy, or Visual Basic, which is a significant achievement for a language that is prized for its safety but not considered as easy to pick up as other languages on this list. The question for Rust, much like Go, is what its broader appeal will be: that will determine whether it peaks in the back end of the top twenty or can continue to grow.

• Scala (-2): The question we asked about Scala in the first quarter’s rankings was simple: “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.” If this quarter’s run is any indication, the answer is the latter. For the third quarter in a row, it dropped, this time two spots to a tie for #14 with TypeScript. It’s unclear what the causative factors are here, and it’s important to note that a #14 ranking is still extremely high. That said, it will be interesting to see how much of the available oxygen for Scala is consumed by Kotlin as the latter continues to rocket up these rankings.

• Swift (+1): Finally, the apprentice is now the master. Technically, this isn’t entirely accurate, as Swift merely tied the language it effectively replaced – Objective C – rather than passing it. Still, it’s difficult to view this run as anything but a changing of the guard. Apple’s support for Objective C and the consequent opportunities it created via the iOS platform have kept the language in a high profile role almost as long as we’ve been doing these rankings. Even as Swift grew at an incredible rate, Objective C’s history kept it out in front of its replacement. Eventually, however, the trajectories had to intersect, and this quarter’s run is the first occasion in which this has happened. In a world in which it’s incredibly difficult to break into the Top 25 of language rankings, let alone the Top 10, Swift managed the chore in less than four years. It remains a growth phenomenon, even if its ability to penetrate the server side has not met expectations.

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.