Your Language Sucks, It Doesnt Matter

This post describes my own pet theory of programming languages popularity. My understanding is that no one knows why some languages are popular and others arent, so theres no harm done if I add my own thoughts to the overall confusion. Obviously, this is all wild speculation and a just-so story without any kind of data backed research.

The central thesis is that the actual programming language (syntax, semantics, paradigm) doesnt really matter. What matters is characteristics of the runtime roughly, what does memory of the running process look like?

To start, an observation. A lot of software is written in vimscript and emacs lisp (magit being one example I cant live without). And these languages are objectively bad. This happens even with less esoteric technologies, notable examples being PHP and JavaScript. While JavaScript is great in some aspects (its the first mainstream language with lambdas!), it surely isnt hard to imagine a trivially better version of it (for example, without two different nulls).

This is a general rule as soon as you have a language which is Turing-complete, and has some capabilities for building abstractions, people will just get the things done with it. Surely, some languages are more productive, some are less productive, but, overall, FP vs OOP vs static types vs dynamic types doesnt seem super relevant. Its always possible to overcome the language by spending some more time writing a program.

In contrast, overcoming language runtime is not really possible. If you want to extend vim, you kinda have to use vimscript. If you want your code to run in the browser, JavaScript is still the best bet. Need to embed your code anywhere? GC is probably not an option for you.

This two observations lead to the following hypothesis:

Lets see some examples which can be explained by this theory.


C has a pretty spartan runtime, which is notable for two reasons. First, it was the first fast enough runtime for a high-level language. It was possible to write the OS kernel in C, which had been typically done in assembly before that for performance. Second, C is the language of Unix. (And yes, I would put C into the easily improved upon category of languages. Null-terminated strings are just a bad design).


This language has been exclusive in the browsers for quite some time.


This case I think is the most interesting for the theory. A common explanation for Javas popularity is marketing by Sun, and subsequent introduction of Java into Universitys curricula. This doesnt seem convincing to me. Lets look at the 90s popular languages (I am not sure about percentage and relative ranking here, but the composition seems broadly correct to me):

On this list, Java is the only non-dynamic cross-platform memory safe language. That is, Java is both memory safe (no manual error-prone memory management) and can be implemented reasonably efficiently (field access is a load and not a dictionary lookup). This seems like a pretty compelling reason to choose Java, irrespective of what the language itself actually looks like.


One can argue whether focus on simplicity at the expense of everything else is good or bad, but statically linked zero dependency binaries definitely were a reason for Go popularity in the devops sphere. In a sense, Go is an upgrade over memory safe & reasonably fast Java runtime, when you no longer need to install JVM separately.

Naturally, there are also some things which are not explained by my hypothesis. One is scripting languages. A highly dynamic runtime with eval and ability to easily link C extensions indeed would be a differentiator, so we would expect a popular scripting language. However, its unclear why they are Python and PHP, and not Ruby and Perl.

Another one is language evolutions: C++ and TypeScript dont innovate runtime-wise, yet they are still major languages.

Finally, lets make some bold predictions using the theory.

First, I expect Rust to become a major language, naturally :) This needs some explanation on the first blush, Rust is runtime-equivalent to C and C++, so the theory should predict just the opposite. But I would argue that memory safety is a runtime property, despite the fact that it is, uniquely to Rust, achieved exclusively via language machinery.

Second, I predict Julia to become more popular. Its pretty unique, runtime-wise, with its stark rejection of Ousterhouts Dichotomy and insisting that, yeah, well just JIT highly dynamic language to suuuper fast numeric code at runtime.

Third, I wouldnt be surprised if Dart grows. On the one hand, its roughly in the same boat as Go and Java, with memory safe runtime with fixed layout of objects and pervasive dynamic dispatch. But the quality of implementation of the runtimes is staggering: it has first-class JIT, AOT and JS compilers. Moreover, it has top-notch hot-reload support. Nothing here is a breakthrough, but the combination is impressive.

Fourth, I predict that Nim, Crystal and Zig (which is very interesting, language design wise) would not become popular.

Fifth, I predict that Swift will be pretty popular on Apple hardware due to platform exclusivity, but wont grow much outside of it, despite being very innovative in language design (generics in Swift are the opposite of the generics in Go).