I think this book is more important than it’s good.
And I’m somewhere in that same vein: I like the idea of this book more than I like the book itself. That is difficult to say without feeling as though I am coming across harsher than I mean to be. I did enjoy Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (7-in-7)1 but my enjoyment is based more around my appreciation for polyglotism (and Tate’s application of it here) than specifically for the languages featured or even Tate’s treatment of the subject matter.
To be clear: I am in no way trying to ding Tate on this.
In choosing to write 7-in-7, Tate took on a daunting task. How do you introduce seven divergent languages with seven divergent styles and seven divergent intents in the space of one book? How do you choose the languages? How do you choose the order in which to present them? How do you present the academic principles in a way that is not so abstract as to have no bearing on what is otherwise on the page? but how do you also not make it so specific to each language that you are (not to turn to aphorisms but…) not losing sight of the forest through the trees?
Tate’s mission is a good one at least: to introduce apprentice or journeyman programmers to a diverse array of programming languages and styles, to help them break out of their comfortable little already-known toolkits.
His approach is at least a half-way decent one, as well:
- Introduce a specific language;
- give three days worth of “lessons” (plus homework); and
- then use the knowledge gained to (hopefully) provide a bridge into the next language/style.2
Unfortunately, the inevitable consequence of Tate’s approach is that you get very shallow coverage of each language3 which (depending on your reading and/or comprehension and/or learning styles) may land you in a sort of cognitive NeverNeverLand where you know that you shouldn’t let yourself get too bogged down in each language’s syntax and/or semantics but your curious nature4 forces you to feel like you need to go deeper on each language if you are to have any hope of getting “the important points” out of each chapter, which (bearing in mind) are about programming styles/philosophies/methodologies and not even about that specific language in the first place.5 Or perhaps more succinctly: you’re reading it for the academic content, but you can’t help but get hung up on the technical details.
And I certainly do not mean that as a deal breaker of a criticism against the book. You cannot possibly expect Tate to go very deep on any of the seven featured languages. He couldn’t possibly–think of how many books are out there written on Ruby alone. But it is something to be thinking about before you decide to crack the covers on this one–are you going to get distracted and go down the Prolog rabbit hole?6 That being said, you will need to be very disciplined in reading this book–either disciplined in performing all of the “homework” self-study exercises, or disciplined in trusting (“having faith in”) each language’s specific syntax whether you’re comfortable/familiar with it or not.
And maybe I’m going overboard by harping on that “language-specific syntax” bit, but that was a real blocker for me in more than a few places. Perhaps that’s just a mark of my “journeyman programmer” status–but I was never able to make a successful heads-or-tails of (most of) Io or Prolog.7 Much of this comes down to Tate’s choices for the languages which he felt were emblematic of or else exemplars of specific programming styles. In the introduction, Tate writes:
Those languages that I picked are not necessarily the best, but each one is unique, with something important to teach you.
And I’ll agree that there is something important to be learned from each one, but you’ve got to get through each one to get to those lessons. And if you’re frustrated and confused by the syntax even when you’re successful…
Yes, I am absolutely confident that that was the point of the book. And yes, I am absolutely glad that I read it. Even if it took me 101 days.
(A shorter version of this review first appeared on Goodreads.com.)
- At least: I enjoyed the majority of it. [↩]
- And I say “language/style” because each chapter is really more about the “style” than the language itself. And when I say “style”, I mean “the foundational principles and/or philosophy behind that programming language”. Because the chapter about “Io” is really the chapter about “prototypal inheritance”; because the chapter about Scala is really about “taking a mixed approach to classical OO and functional programming styles”; etc. [↩]
- Tate even comes right out and says in many instances that he is just barely scratching the surface of each language, that he is giving some language feature a barely cursory overview, or else leaving it out all together. So you wind up with your appetite whetted but without any satisfying take-away knowledge (e.g., my experience here with Scala and Clojure), or else you’re turned off to that language all together (e.g., my experience with Io and Prolog). [↩]
- …and you obviously have a curious nature since you are a polyglotically-inclined developer that decided to pick up Bruce Tate’s 7-in-7 to begin with. [↩]
- And if that seems like a mixed up and backward… Well, that’s how I felt reading it. (Also: remember that emotion trumps logic?) [↩]
- I’m being a little unfair to Prolog here, but I just did not have the patience for it. (But then again, I didn’t really have patience for Io or Erlang either…) [↩]
- And I think I said this already but I got stuck in more than a few places with Erlang, too. [↩]