Wow! Those were seven exciting weeks following a wonderful journey through seven fantastic languages, each with their own specialties. To three of the languages I was completely blank, with the other four I was (a bit) familiar.
The journey started with Ruby, a language that adopts today’s mainstream programming paradigm of object orientation, and with so much syntactic sugar that every programmer is able to understand what’s going on.
Through the Io language that uses the prototype based programming style (also the object oriented paradigm) the book went on with logic programming using Prolog. This is completely different from the first two languages, and lays a firm foundation for some of the languages to come. It also drags you into recursion.
From Prolog the journey took a turn for a more functional style of programming. First stop was Scala, the object oriented and functional hybrid. From thereon the destinations were Erlang, Clojure, and finally the purely functional Haskell.
The author, Bruce Tate, kicks off every language with an introduction and some background information on the language. By the order of the languages you can notice that Bruce did his best with each language to provide a foundation for the next one. I am not sure if Bruce intended it this way, but for me it felt like everything came together in Haskell.
I really enjoyed this vast journey through these seven languages. It’s very interesting how they all have their own strengths and weaknesses, each of them being great at what it was created for. Some of them are applicable to more general purpose programming, others solve a very specific set of problems.
In the book Bruce sometimes speculates a bit about the future of languages and whether or not languages can become mainstream. Below are some of my thoughts about this.
There is no longer any doubt that functional programming techniques become increasingly important as our hardware gets more concurrent. Using threads to do concurrent programming just won’t do if programmers must be productive. Moore’s law these day’s no longer applies to the speed or our hardware, but it does seem to nearly apply to parallelism. Our hardware doesn’t get twice as fast every year, but it gets twice as parallel every few years.
That said, I think that the best candidate to become a mainstream language is Scala, simply because it offers a smooth transition from object orientation to functional programming. Personally I doubt whether this is actually helpful. It’s much like C++ transitioned many programmers from procedural programming in C to the same way of thinking with objects that is still much applied today in mainstream languages as Java and C#. [Of course this wasn’t all C++ did and no offense towards C++ is meant in any way.]
At the moment I believe Ruby is becoming a mainstream language, but without many programmers who use it actually knowing it. Tools like Puppet or Chef offer a configuration DSL written in Ruby, where programmers can fallback on Ruby for doing more complicated and exotic configurations. As a scripting language that is available on all major platforms it is great for building system administration tools and configurations. It is rather ironic how offensive many Java programmers are against Ruby (or all dynamic languages for that matter) and at the same time telling how much they like the configurations of Puppet.
To anyone who is passioned about programming I would strongly suggest reading this well-crafted piece of work. Especially if you haven’t learned a new language in a while, let me remind you Andy Hunt’s advice in The Pragmatic Programmer to learn a new language every year.
As I mentioned in the articles, Ruby and Clojure belong to my favorite languages today. And for Erlang and Haskell there’s much to learn, which I intend to pick up next year.
Thank you for joining me on my journey. I had a great time, I hope you did too.