Valar morgulis, but what does that mean for coding?

Java is likely to outlive Go: How can we judge which programming languages will survive?

Jane Elizabeth
programming languages
© Shutterstock / LanKogal

Predicting the death of a programming language is notoriously tricky. Java has been declared doomed nearly half a dozen times and it’s still kicking. But can we apply mathematical principles to the problem? The Lindy Effect says yes.

Judging the lifespan of a programming language is a notoriously tricky prospect. For starters, it’s not like developers can look at actuarial tables. Besides, there’s nothing more embarrassing than prophesizing the end of Java, only to be soundly proven wrong.

(We’ve got a long history here at JAXenter of laughing at people predicting the end of Java. You can see more here, here, here, here, here, here, here, and here.)

Programming languages don’t have a natural lifespan; even if they did, the field is still too young to make assumptions. After all, the first computers only really became a thing in the 1950s. FORTRAN was created in 1954 and it’s still used in places.

The Lindy Effect

Determining the lifespan of creative artifacts is something of an art. There’s an idea floating around called the Lindy Effect. The Lindy Effect states that future life expectancy of a nonperishable good is proportional to its current age. Basically, it suggests that the longer something has been around, the longer it will stay around.

So, according to this theory, young things may be popular now, but they might be unlikely to stand the test of time. (The “live fast, die young” crowd.) Whereas older options have got all their life to live and they will survive.

Of course, this sets the Lindy Effect up for a certain amount of survivorship bias, but that’s neither here nor there.

How does this relate to programming languages, though? It tracks with general knowledge: older languages seem unkillable – FORTRAN, BASIC, and COBOL might not be the most popular languages, but there are still jobs in each of these languages. NASA made headlines when they posted a job requiring assembly languages, but there’s a finite amount of legacy language jobs.

SEE MORE: Java is alive and well, thank you, and is just as relevant as ever

Newer languages like Go, Python, Java, and C have more to prove. Well, probably not Java or C. I think C is a survivor and going to make it. And Java? I’m calling it now: it’s going to take an asteroid to kill off Java.

John Cook has an interesting post about his predictions for programming languages. While this is for fun, it’s interesting to see what might be a flash in the pan language and what might stick around for years to come. Here’s what he predicts:

Programming Language     Born     Expected Death
Go     2009     2025
C#     2000     2034
Java     1995     2039
Python     1991     2043
Haskell     1990     2044
C     1972     2062
Lisp     1959     2075
FORTRAN     1954     2077


Cook doesn’t go into his methodology, so we’re not really sure where he got these estimated time of deaths. (Possibly from his earlier post on the Lindy Effect?) But, we’ll all check back in 8 years to see if he was right about Go.

What do you think? Can we guess the year a programming language will fall out of use and “die”? Let us know in the comments.

In the meanwhile, I’m going to bet on Java. I think they’re going to make it.


Jane Elizabeth
Jane Elizabeth is an assistant editor for

Inline Feedbacks
View all comments