As many are aware, our latest analysis of the programming language rankings has been delayed. While there are a number of factors that have contributed to this including schema changes and query issues, the biggest single factor in the latency between this ranking and its predecessor was our attempt to explain some serious anomalies discovered in the data. We can’t definitively identify the source of those as yet, but our current hypothesis is that they are manifestations of the acceleration of AI code assistants. We’ll continue to monitor the impact of these tools on both the industry and the underlying data that these rankings are built on.

In the meantime, however, as a reminder, this work is a continuation of the work originally performed by Drew Conway and John Myles White late in 2010. While the specific 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 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. If a given language is not present in this analysis, that’s why.
• 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.
• Languages that have communities based outside of Stack Overflow such as Mathematica will be under-represented on that axis. It is not possible to scale a process that measures one hundred different community sites, both because many do not have public metrics available and because measuring different community sites against one another is not statistically valid.

With that, here is the first quarter plot for 2024.

1 JavaScript

2 Python

3 Java

4 PHP

5 C#

6 TypeScript

6 CSS

8 C++

9 Ruby

10 C

11 Swift

12 Go

12 R

14 Shell

14 Objective-C

16 Scala

17 Kotlin

18 PowerShell

19 Rust

19 Dart

The top 20 languages cohort was not devoid of movement this run, but it was more static than not as we’ve come to expect in recent years. There was no movement in the top 5 languages, and less than a third of the top 20 languages moved at all. For better or for worse, these metrics reflect an environment resistant to change.

The last analysis of these numbers considered the possibility that coding assistants had the potential to ease and speed the uptake of new languages by lowering barriers to entry and speeding ramp up time in adopting new, unfamiliar languages. If that’s occurring at present, however, it’s not observable in the data. We see some new language entrants, and we have a list of languages of interest from our qualitative research, but to date these rankings offer minimal evidence of any AI-fueled acceleration of new language adoption.

With that, some results of note:

• Go: two years ago at this time, Go had lost its forward momentum and fallen back into 16th place, and it wasn’t clear what emerging use cases might reverse its fortunes. As of this run, it is up four spots over that span to place it in a tie with the steady R language at 12. There’s no obvious reason for this resurgence, but anecdotal evidence suggests that Go’s blend of accessibility, design and performance have rendered it a reasonable language of compromise for back end development use cases.

TypeScript: ever since it became the first new entrant to our top 10 since – for one brief quarter, Swift – TypeScript has been the language to watch. Its upward trajectory has been slowed over the course of its ascent as these metrics are accretive in nature, but this quarter’s run continues a period of slow but steady growth as it moves up one spot from seven to six. With an ever increasing industry focus on security as well, it’s not implausible that the language has further growth yet in front of it. It’s arguable that some of that growth came at the expense of our next language, in fact.

C++: in the initial incarnation of these rankings, C++ debuted at 7. It climbed as high as 5 at times, and recently had settled back into seventh place. For this run, C++ dropped to eighth place for the first time in the history of these rankings. It’s important to note at this point that top 10 languages are, relatively speaking, enormously popular and have achieved a ranking that dozens if not hundreds of other languages would envy. All of that said, it’s worth asking whether C++ can sustain its back end popularity in the face of the influx of more modern and accessible lower level languages like Go or Rust.

Dart / Kotlin / Rust: speaking of Rust, the notable thing about it as well as Dart and Kotlin, as has been true in recent quarters, is that there is no news. All three of these languages have outperformed their various peers to achieve entry into our top 20, but none have been able to capitalize on their newfound popularity to resume their upward trajectory in the manner of TypeScript. The incumbents ahead of them have proven hard to displace, and there is also emerging competition for some of the languages from the likes of Zig as we’ll come back to.

Swift: even in a long list of languages that have been static in their progress, Swift stands out having not moved one spot in either direction in six years. To put that in context, the last time Swift wasn’t 11 in our rankings Google’s transformer paper was merely one quarter into its journey towards upending the technology industry. On the one hand, as noted above, this means Swift is enormously popular as a language. On the other hand, its ranking and the lack of objective evidence to the contrary seems to prove that the efforts to make Swift more of a force for server side applications have failed.

Bicep (86), Grain, Moonbit, Zig (97): as with the Dart/Kotlin/Rust grouping above, these languages are grouped here not because they’re all technically similar but rather because they are on the languages of interest list mentioned above. They are included here for a variety of reasons: Zig is on here because it has attempted to learn from the languages that preceded it from C++ to Rust. Grain and Moonbit are on here, meanwhile, because they are optimized for WebAssembly. Bicep is on here because it comes up with surprising frequency – and a mildly surprising ranking – for a cloud DSL. Only two of these languages are currently ranked, but we’re watching all of them to see if these or any other new languages begin to emerge.

Credit: My colleague Rachel Stephens wrote the queries that are responsible for the GitHub axis in these rankings. She is also responsible for the query design for the Stack Overflow data.