Communications of the ACM

ACM Careers

RedMonk Releases 2018 Programming Language Rankings

By RedMonk
March 9, 2018
Comments

RedMonk has published its Q1 2018 Programming Language Rankings. The rankings are a continuation of the work originally performed by Drew Conway and John Myles White late in 2010. While the means of collection have changed, the basic process remains the same: RedMonk extracts language rankings from GitHub and Stack Overflow, and combines 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, RedMonk changed the way that GitHub's rankings were collected due to changes in the data's availability.

The data source used for these queries is the GitHub Archive. RedMonk queries languages by pull request in a manner similar to the one GitHub used to assemble the 2016 State of the Octoverse. The query are 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 the previous methodology.
• Forked repos are excluded.
• The aggregated history is used 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 the rankings cannot be replicated as they were prior to 2017, the results were generally correlated with 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.

One other minor change was made for this run. Historically, the rankings' Stack Overflow tag counts have been collected direct from the source—stackoverflow.com. While this was the initial collection process, the spreadsheet containing the January 2018 tag counts became corrupted and unusable. With a helpful pointer from Stack Overflow itself, however, RedMonk was able to collect the required metrics using Stack Overflow's data explorer tool. The results differed slightly from the website, but not materially as far as could be discerned, but the potential influence is worth noting.

Other caveats apply:

• 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  believed 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 first because of their size and second because of their public exposure of the data necessary for the analysis. Interested parties are encouraged to perform their own analyses using other sources.
• All numerical rankings should be taken with a grain of salt. Rankings are numbered 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 by which to rank languages. 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.

The first quarter plot for 2018 follows here.

(Click to view enlarged image)

Besides the above plot, which can be difficult to parse even at full size, please see the following numerical rankings. As will be observed, this run produced several ties which are reflected in the rankings (ties are listed out 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 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 the Top Ten, then, with one exception which will be addressed, 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 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 the rankings, actually fell off a spot down to #16. To be clear, it is recommend to not read 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 noted in RedMonk's 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 the Q3 run to #27 as of January 2018. 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 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 the 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 the previous 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 asked about Scala in prior 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 these rankings have been assembled. 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: 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.

---

No entries found