During the day I create Java EE web applications, at night I experiment with all technology I can get my hands on (lately ActionScript, 3D, Python, ...) and write about it on my blog Streamhead Peter has posted 3 posts at DZone. View Full User Profile

Seven Languages in Seven Weeks, Bruce Tate

02.03.2011
| 16902 views |
  • submit to reddit
Published by: The Pragmatic Bookshelf
ISBN: 9781934356593

Reviewer Ratings

Relevance:
4

Readability:
5

Overall:
5

Buy it now

One Minute Bottom Line

Seven Languages in Seven Weeks is an introductory book to seven very different programming languages. It is intended to show the object oriented programmer that there is an entirely different world of programming languages out there. Languages that do not adhere to a syntax or programming model that you have grown accustomed to. It requires a lot of dedication from the reader, so it is not an easy book, but it brilliantly executes its goal and opens your eyes to an entirely different, sometimes foreign, programming world.

Review

In Seven Languages in Seven Weeks, Bruce Tate is set on expanding your horizon and showing you new programming paradigms and entirely new ways of looking at problems. Some of the languages might sound completely alien to you, some you might have heard about but don't quite know what makes them truly special. This book will give you a crash course in Ruby, Io, Prolog, Scala, Erlang, Clojure and Haskell, covering the language, the ideas behind the scene and a number of excercises to discover the language by yourself.

The book

This review is written based on the eBook version; it comes in 3 formats, all specifically laid out for the targeted screen resolution. I read the epub format in Stanza on my iPod Touch. Overall the epub version was well done, although it did not work very well for larger code samples, which was to be expected. For those cases, I switched to the PDF version on my laptop. This is certainly not a problem with this particular book, the iPod's screen is simply too small.


The bulk of the book consists of 7 chapters, one for each of the 7 programming languages. Ruby, Io, Prolog, Scala, Erlang, Clojure and Haskell are covered in that order. Each chapter has the same structure: a short introductory background on the language, 3 days worth of lessons and exercises, and finally a wrap up containing a summary of the reasons why and when you may or may not choose to use the particular language.


For each language, the “day one” chapter quickly introduces the language syntax so that you can write a number of small programs at the end of the lecture. The other two days highlight specific parts of the language that are unique to that language or the programming paradigm. Because of this structure, sometimes this means that plain, uninteresting, language features are skipped over and left as an exercise to the reader.

None of the chapters are particularly long and most of the exercises can be done in about an hour. Most “day” chapters can be read and the exercises done in an evening. Obviously this will greatly depend on your experience, the amount detail you want to go into and how much you rely on Google to solve some of the tougher problems.

To keep the story entertaining, every language is compared to a movie character. While not necessary, I thought this was a nice touch and it worked quite well.

My personal experience

This book is squarely aimed at experienced programmers. The introduction states clearly that some dedication will be required to get the most out of the book. If you do not intend to do the exercises, you might as well skip the book. I can concur that you will only get the most out of the book if you, at least, try to do the exercises yourself. The real hands-on experience with the languages is what turns this book from good into great.

Learning the different paradigms and syntaxes is a real challenge, doing it in seven weeks is certainly a daunting task, yet it is also extremely fulfilling afterwards if you look back at the vast number of lessons learned.

One thing I found especially successful about the book was the choice of languages and the order in which they were presented. According to the introduction, the choices were made through an Internet vote, with only minimal changes by Bruce Tate himself. That worked out really well.


The order is perfect for two reasons:

  • There’s a very nice gradual rise in difficulty. Ruby, the first language, is a fairly known language that most Java or C# developers can quickly pick up. The book ends with Haskell and monads. For an objected oriented programmer like me, that was a real mindbender (and the exercises took me way longer than any of the previous chapters).
  • I’m not sure how Bruce Tate managed to pull this off, but for each language, there are new constructs and ideas introduced. That means there’s not one chapter where you might get bored thinking “been there done that”. For a book with a subject matter this eclectic the flow is very good.

I noticed that the theoretical part of the book places a fairly large focus on concurrency mechanisms. It’s certainly something that is unique to the languages and it might be one of the major reasons why you switch languages in the future. In contrast with this theoretical coverage, I thought concurrency was maybe a bit under-represented in the exercises.

The exercises themselves are usually split up in two parts. In the first part you have to look up certain things that will help you in executing part two. Part two is the actual programming in the language. With a few exceptions, the tasks are short and open to interpretation. Some people will solve many of the exercises with only one or two lines of code, while others will want to implement a much more robust solution. Depending on your knowledge and interest, you will spend between one and several hours digging into the new programming language.

It’s probably worth noting that all languages are available for all operating systems, with one exception. There was no up-to-date binary distribution for the Io language and it took me a while to compile a functional core on Windows. It was all worth it because Io was one of the languages I enjoyed the most.

Conclusion
Seven Languages in Seven Days is a great challenge that every experienced programmer will thoroughly enjoy. You won’t learn any of the languages in depth, but you’ll get a well written and focused introduction to the new programming paradigms and unique features. After that, you’re on your own. You may choose to pursue a language, or you may use the gained knowledge within your current programming language. One thing is sure: you’ll never look at object oriented programming in quite the same way again.

Published at DZone with permission of its author, Peter Backx.

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)