Welcome to the home page of Eric Dykstra!

This is my home on the internet, where you can find everything Eric. From where I'm spending my time now, to introductions to my current and past projects, to my writings about anything I'm thinking of (currently migrating blog to this new site).

I just re-launched this site, and am in the process of migrating my blog posts, but until then, here's one of my old posts! ↓


The Best Programming Language to learn in 2019

What programming language is the most useful to know in 2018? Should I use PHP on my next project? Should I study Go or Rust? These are the kinds of questions that get asked over and over on Q&A sites and forums. The answers are often varied, and include some mix of flavor-of-the-month languages, old standbys, or whatever language that particular writer is interested in or evangelizing.

So instead of giving you a list of hot languages and technologies and publishing updates every month, I'm going to introduce you to a timeless heuristic that you can use to help make all future technology decisions.

The Lindy Effect

The Lindy Effect is the idea that every additional day that anything non-perishable (an idea, a play, or a technology) stays relevant, it is expected to stay relevant for that much longer. For example, 200 years from now, humans will almost certainly be using a drinking glass nearly exactly like the one you use now, because drinking vessel technology has not significantly changed for thousands of years. Similarly, we expect people will still be listening to the Beatles in 50 years. Conversely, despite growing adoption and wide popularity now, the USB-C standard and Beyonce both almost certainly doomed to obscurity long before the drinking glasses or the Beatles fall out of favor.

Now that you get how the Lindy Effect works, let's look at how it might apply to programming languages. We can start by taking a look at the [TIOBE index](http://www.tiobe.com/tiobe-index/) as a proxy for language popularity. If we look at the top 10 for this month, the 3 oldest languages are C (1972), C++ (1983), and Object Pascal (1986); while the youngest languages are Swift (2014), Visual Basic .NET (2001), and C# (1996). Looking at nothing else, the Lindy effect tells us that, on average, the first 3 will be relevant longer than the latter 3.

It's the nature of working in technology that we are subject to a certain amount of neomania. And there is some good reason for this; technology can be corrected over time. We see this in updates of existing languages: minor and major version updates that fix bugs, speed up compiling, and introduce new features. These incremental corrections strengthen the technology over time. When these changes go beyond incremental improvements and into the realm of substantial changes, we can see a situation like Python 3 or Angular 2, where a large portion of the community stays behind, the base fractures, and the technology suffers as a result.

How I used Lindy to help choose which programming language to study

There is a lot to be said for learning a new programming language. Learning a language with a different primary use case or paradigm can greatly improve one's general programming proficiency. The classic book, *The Pragmatic Programmer*, advocates learning one language every year for these reasons, and any language that is sufficiently different from what you already know can be an amazing learning experience. But personally, if I'm going to go deep on a new language (or framework), I want to choose one that will also be useful for me professionally and not be outdated before I get a chance to use it in production.

So how did I choose which language to add to my programmer toolkit? I considered a number of them. Go was hot for a while and is still growing, but is losing a little helium. Rust seems to be the new language de jour among many in the big online programming communities. Swift has the power of Apple behind it, and proponents point out how quickly it is improving and becoming viable beyond just iOS development. Elm has a unique programming paradigm, and looks like a promising way to write front-end code without having to write JavaScript. So how to choose?

I ended up choosing Elixir (and Erlang). While Elixir is another new language, and Erlang has never been as popular as contemporary languages like Go and Swift, it passes the Lindy test. For fault-tolerant, concurrent, distributed systems Erlang has been used to great success for over 30 years. The use-cases for this kind of system, and thus Erlang, have only increased as the web has become more real-time. Neither language may ever crack the TIOBE index, but, by Lindy standards, I firmly expect Erlang to be powering messaging services, game servers, and anything else that requires the power of Erlang's virtual machine for the next 30 years.

Asking Lindy how I should host my blog

I could have gone with a "modern" stack and used Docker and AWS, or used a system abstracted on a higher-level layer like Heroku. Instead, I went with using a simple cheap Virtual Private Server, running all of my sites from a single VPS instance running Ubuntu Trusty Tahr, and putting my sites behind an NGINX reverse proxy. It might not be as hip, but I learned how to manage a time-tested system for hosting and serving websites, and I don't need to bother keeping up with the latest in container news and updates just to keep pushing new posts to the world. Since I don't expect to need to scale this blog, or any of my other projects any time soon, learning and using this standard production stack looks to be the best use of my time.

Use this heuristic yourself!

Whether you're suffering from JavaScript fatigue or just agonizing over which language to learn, try seeing if this heuristic can be a bit of a guiding light. Don't be dismissive of older programmers dismissing new languages, assuming they just want to protect their jobs without having to learn something new; they might just know about the faults of neomania from their experience.

Not everyone will heed this advice, and that's a great thing. Without people making irrational decisions to dedicate vast swaths of their lives to the development of groundbreaking technologies, we wouldn't be making progress. Just be aware that the vast majority of Elm, Nim, React, Docker, Go, Rust, Swift, Dart, Perl 6, Julia, Python 3, any other new language, technology, or framework that has debuted in the last 10 years will likely not be relevant 10 years from now.

The Lindy effect, of course, is just one heuristic. There are many other factors to consider when deciding which language or technology to study or use on your next project. What fits the requirements for the project? What does your team use? How easy is it to get up to speed? How will it affect hiring programmers?

Further reading

An Expert Called Lindy - A chapter from the book, Skin in the Game by Nassim Nicholas Taleb

The Pragmatic Programmer - Classic programming book

Erlang: The Movie - Video introduction to the Erlang programming language, from 1990. If this doesn't convince you that this is the wave of the future