First of all, let me explain why I decided to read through this book in the first place. As someone who’s been programming pretty much exclusively in Java and Javascript for the past couple years at my job, I decided it might be a good idea to try out some other programming languages outside of work to broaden my perspective. I’ve dabbled a bit with other procedural / object oriented languages in the past, but after working with Redux and using some of Java 8’s more “functional” features I flet like giving some more functional languages a try.
I mentioned to my manager in our weekly one on one meeting that I was taking more of an interest in functional programming. He told me there was a book he read called “Seven Languages in Seven Weeks” that went through a few different programming paradigms and there were some functional languages covered in the book. This was the first time I had ever heard of the book, and since I wasn’t totally sold on any one new language to try out I decided to give it a go.
Going into the book I tried to give myself pretty realistic expectations. I don’t think you can expect anyone to master a programming language in a week’s time. What I think you could learn would be some basic syntax and probably enough language features to solve a few smaller problems. What I was hoping to get out of the book wasn’t to really learn or master any of these languages, but rather to find out what different approaches each language took to solving problems and what made these approaches effective.
Working through each of the exercises in the book felt like a real grind by the fifth chapter or so, but I’d still recommend anyone reading this to at least attempt the exercises at the end of each section. In order to get an understanding of what each languge brings to the table, actually using each languge to solve problems is the best way to learn. I tried to motivate myself to complete these exercises by pushing the solutions up to a git repository, but going through the book with other people in a study group would work as well.
The seven languages covered in the book in order are Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell. Out of the seven, I found Ruby, Io, and Scala to be the most intuitive, probably because they were the three that most closely resemble languages I’m used to using.
I was really surprised how much I enjoyed the chapter on Prolog. I hadn’t worked with a constraint based logic programming language before, so writing programs that could solve complex problems by listing out requirements was a very eye opening experience.
Clojure seemed a bit easier for me to work with compared to the other functional languages in the book, despite my not having much exposure to a Lisp like language outside of a course I took in University several years ago. I think the combination of having a super simple syntax and build tools like Leiningen that use familiar JVM conventions helped a lot with getting more productive quickly.
Overall I enjoyed the book and would recommend it to anyone who’s looking for a bit more of an in depth comparison between programming languages using differrent paradigms. If you’re looking for a resource to become an effective programmer in several different languages quickly, you might be disappointed. For those looking to master a new programming language, I would use this book as a shallow introduction to many different languages so you can decide for yourself what to study next.
