State-of-the-art development: old approaches retain their charm

SICP

These days, the life of the IT professional can be really interesting. We have the opportunity to change the lives of millions of people by solving problems of an ever-growing complexity: internet-scale applications with massive user bases, petabytes of data to crunch in order to discover non-evident relationships and real-time natural language processing just to name a few. To face them, we are quickly evolving to new computing models, new ways of working that allow us to overcome the challenges we find at every turn. It may come as a surprise, therefore, to find that some key tools now becoming mainstream are perfectly explained in a book published in 1985.

Finding an old book

As someone in the cloud infrastructure engineering business – the old hosting engineering – I cannot overlook how software systems are becoming more and more important in a field that has always been the almost exclusive domain of hardware appliances. On that count, I try to stay up to date in the state-of-the-art techniques, paradigms and methodologies in the Software Engineering area. While in one of the coding meet-ups I am attending, some of the guys started a humorous chat about a book I had never heard about: The Structure and Interpretation of Computer Programs. The conversation turned into the usual my-language-is-better-than-your-language so I quickly lost interest. The name of the book, however, grabbed my attention and I decided to take a look at it. The first positive surprise was that the book – SICP from now on – is under a Creative Commons license and freely available to browse. It was then when a realized the text had a first edition dating back to 1985 and a second one to 1996. I skeptically raised my eyebrows. Will an old manual like this be worth the time spent? Will it be interesting? With these questions in mind, the reading started.

Going over it

It is not uncommon that when you study a book on programming, you end up needing to learn a new language. As an example, the fantastic Object Oriented Software Construction does a great job of describing the OO techniques using Eiffel. Consequently, seeing that SICP uses LISP – the Scheme variant – was not exactly a shock. Even more when I am somewhat familiar with Clojure, a language cut from the same cloth. Regarding the content, it is a book about software construction and, as such, it describes some of the classic topics already discussed in other books both new and old. They include: functional and imperative paradigms, data immutability, concurrency and its effects on program evaluation, recursion, tail-call optimization, scoping, closures and even compiler and interpreter construction basics. The Scheme code for examples and exercises may be a little bit challenging but gets easier to read as you get used to it. However, besides expected points, the book also describes concepts that, at least for me, where not supposed to be there:

  • Filter-map-reduce pattern.
  • Streams / infinite streams.
  • Lazy evaluation.
  • Non-deterministic program evaluation and Continuation Passing Style.

Do they ring the bell? Of course! They belong to the tool-set we use now to address some of aforementioned challenges: big data, natural language processing, etc. They may sound new, they may even sound bleeding-edge but the truth is that they come not only from the more academic environment but also from our distant past (in computing terms).

Why is this text relevant?

In my humble opinion, because of three main reasons: 1. It describes some of the foundations of programming. Foundations are always a good thing. You can’t build a great building on a weak foundation. 1. It does it using a functional language. Functional languages help introducing important concepts: referential transparency, data immutability, etc. In the beginning they seem to be a pain but they prove themselves to be invaluable once we get used to them. 1. Some (if not all) of the methods described thirty years ago have proven to perfectly suit our needs today. In a world of very large data-sets, complex algorithms and highly concurrent environments, the mechanisms backed by the functional approach work really well.

My recommendation: read it

As a summary, the size and complexity of the problems we are facing and the techniques we are using to do it are bringing back some software development concepts and tools that used to be considered of purely academic. A part of the so-called functional world.
Academic or not, they seem to be helping us today and SICP does a very good job on showing some of them. Admittedly, the book is not extremely easy but the it is definitely worth the time. I would recommend anyone interested on the latest trends on software development to give it a try. Bonus points if you go through the exercises.