A few years ago, I picked up and started reading through Bruce Tate’s 2010 book Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages. I had heard quite a few people I respect refer to it (and its sequel, Seven More Languages in Seven Weeks) as having significantly altered the trajectory of their careers. I did not tackle it in a single 7-week stretch, because: life. I have made slow but steady progress on it since then: every so often picking it up and working through one of the chapters — one of the languages! — and I finished it today.

It is easy to see why it made such a dent in the industry. Back in 2010, the current wave of new programming languages was perhaps on the horizon for those who knew where to look — Tate himself being a good example of such connoisseurs — but by and large we were living in a world profoundly dominated by Java and C♯, with the alternatives being some mix of scripting languages: PHP, JavaScript, Ruby, Python. When this book came out, Rust was still a relatively early-phase research project inside Mozilla. Swift was just getting going inside Apple, TypeScript at Microsoft, and Kotlin at Jetbrains. (Something must have been in the water in 2010!) Plenty of people were doing interesting things in other languages, but the scene was nothing like it is today. Tate’s book, from a well-respected press, was thus able to make a big dent in the landscape.

For my part, I learned a few things along the way, but the book was not revolutionary. I think if I had read it in the first five to seven years of my career it would have been mind-blowing, but at this point in my career it was largely things I already knew. That is in no small part, though, because of the indirect influence of Tate’s book! Many of the languages here I had looked at already precisely because I had heard of them from other people who have read it. Others were less novel because I have used languages influenced by them. The major exception was Prolog: I knew that logic programming existed, and went to a fascinating talk on Mercury back at LambdaConf 2017, but that was it! And to be fair, Clojure would have been largely unfamiliar to me if I were not neck-deep in Racket for other reasons!

Even with that caveat, this is definitely a book I think every working software engineer should work through when 3 – 5 years into a career (unless they happened to have a particularly good undergraduate computer science education which exposed them to all of this). Seeing how different languages can offer up different semantics and different syntax for similar semantics is a really important part of learning to program well, even if you spend your whole career in mainstream languages.

The choice of languages has definitely aged in uneven ways:

• Ruby (on Rails) is no longer the language of choice for every hot new startup, but it indelibly stamped the way web development works, and it remains a widely-used and much-loved language. It may have “peaked” — but the history of Python, of much the same vintage and having made significantly greater blunders than Ruby, shows that any such prognostication is apt to go wrong, because language popularity is so path dependent.¹

• Io was niche when Tate wrote about it, and it is niche today, but it also continues to be interesting — and maintained! Though it is also “done” in a real way. It is message-passing-and-prototypal-objects all the way down, and made some really good choices syntactically for those semantics, so it feels really nice.

• Prolog is probably the “oddest” language in the book in that logic programming as a discipline remains largely untapped, in part because its application to “business problems” is less obvious than other programming paradigms. Unlike Io, it is niche because its entire world is niche, rather than because it did not catch on as a bigger thing.

• Scala was probably at the very peak of its popularity to date as the book came out. Many of the Bay Area tech companies were adopting it as a Java replacement, leaning into its hybrid model which mixed object-oriented and functional idioms.² Unfortunately, the combination of a slow compiler, poor data structure performance in the early days, and the reality that most programmers just ended up using it as Java with a really weird syntax meant that it ended up with a bad reputation in the Valley and receded to a niche space for functional programming enthusiasts who needed or wanted to run on the JVM. The folks who preferred OO had a much smaller learning curve and more familiar syntax to just use Kotlin

• Erlang itself does not seem to have grown much in popularity as a language, though it definitely had a nice little spike of interest when people realized just how effective it was for pre-acquisition WhatsApp.³ However, the BEAM VM has become and increasingly popular target for other languages, starting with Elixir but now including quite a few others. Somewhat bizarrely to me, despite the boom in microservices in the 2010s, relatively few people seem to have taken a serious look at what Erlang and the BEAM bring to the table.

• Clojure had a bit of a boom at the same time and for a few years after the book came out. Growth seems to have leveled off, in part I suspect because the aforementioned Kotlin took a lot of the energy in the JVM world, and with a far lower “activation energy” than jumping into a Lisp — even a well-designed one. It has not gone anywhere, but like Ruby seems to have stabilized (and perhaps peaked), at least for now — but as with Ruby, the future is unclear.

• Haskell seems to have made some more inroads over the 2010s, both propelled by and contributing to an uptick in functional programming in general. It has seen production use at Facebook and GitHub and plenty of other. Arguably it continues to have its most significant impact indirectly, though, via its home as the dominant incubator for many ideas in typed programming — and via the contributions of its descendant language Elm, which did more to change how programming language developers approach compiler interactions than perhaps any other language in modern history.

It was always unlikely that any of those languages would surge to be completely mainstream, of course. However, many of the new languages which have become mainstream in the interval owe a good deal to those mentioned here. Too, these remain worth knowing something about in their own right. This is a good book, still worth a read.

---

Notes

1. The effect of path dependence on language adoption (or even framework adoption) is something I think about a lot. Might be an essay there, eventually. ↩︎

2. This was less novel than its proponents (…or language designers) claimed; OCaml (then Objective Caml) had been public for half a decade when work on Scala started! And… OCaml does it a lot better. ↩︎

3. My understanding is that Facebook rewrote it entirely at some point after acquisition. ↩︎