Self-driving startup Drive.ai Acquired By Apple
19 days ago
Programming Language Rankings January 2019 By IBM From Java to Node.js
- 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 to rank (though based on the table structure changes this can no longer be accomplished via a single query.)
- 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.
- 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.
- Go (-1), R (-1): With TypeScript jumping into the twelfth spot on the rankings, something had to give and in part, it was Go and R which dropped one spot respectively into a tie for #15. In the grand scheme of things, this is relatively meaningless as the difference between one spot and another is often superficial, particularly the further down the list a language is found. This is particularly true for the R language, which continues to demonstrate robust, near Tier 1 usage thanks to a vibrant base of analytical and data science use cases. Given the domain-specific nature and comparatively narrow focus of R, its prospects probably do not include a Top 10 placement; the mid second tier is likely it's the ceiling. Go, on the other hand, it is reasonable to question what its stagnation in this second tier means for the language's future. It is highly regarded technically and enjoys popularity across a wide variety of infrastructure projects. To date, however, it has not demonstrated an ability or inclination to follow in the footsteps of languages such as Java and expand its core use cases.
- Kotlin (+8), Scala (-1), Clojure (-3), Groovy (-3): One of the primary questions we had going into this quarter's rankings was whether or not JVM-based languages such as Clojure, Groovy and Scala could repeat the last rankings' performance in which all three grew while newcomer Kotlin declined. We now have a clear answer to that question, and it's no. For this quarter, at least, Kotlin grew substantially while all three of its fellow JVM-based counterparts declined. Kotlin jumped so far, in fact, that it finally broke into the Top 20 at #20 and leapfrogged Clojure (#24) and Groovy (#24) while doing so. It's still well behind Scala (#13), but Kotlin's growth has been second only to Swift in this history of these rankings so it will be interesting to see what lies ahead in the next run or two.
- Julia: For a language that isn't even in the Top 30, Julia continues to attract questions about its performance and future. Its growth has been more tortoise than hare, but it's up another two spots to place #34. While there is no technical basis for comparison, it is worth noting that three years ago in our Q1 rankings TypeScript made a similar modest jump from #33 to #31. That is not to say that Julia is destined to follow in TypeScript's footprints, of course, but rather to serve as a reminder that while it's uncommon languages can transition quickly from periods of slow, barely measurable growth to high, sustained growth quarter after quarter.
- Rust: Last on our list is Rust, which neither grew nor declined but instead held steady at #23. This may be disappointing for its more ardent fans, which include some high profile and highly accomplished technologists, but Rust's glacial ascent is relatively unsurprising. Targeting similar if lower level workloads than Go, a language itself that has plateaued in terms of its placement amongst these rankings, Rust suffers from the limits of a lower popularity ceiling while not receiving quite the same attention that Go did as a product of Google generally and people like Rob Pike specifically. By comparison, Rust's ascent has been much more workmanlike, winning its serious fans over one at a time. It's also worth noting that even if Rust never gets much beyond where it is today, it's still ranking higher than well-known languages such as the aforementioned Clojure and Groovy, as well as CoffeeScript, Dart or Visual Basic. Not bad for a systems language.