Seven Languages in Seven Weeks

I don't remember seeing this book discussed here: Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages by Bruce A. Tate.

It seems very a very LtU kind of thing. If you read it, do share your opinion.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Seems too cursory

I've not read the book, only the sample chapters on the website. Those seem to barely touch the surface of their languages, though I did like the introduction to Icon.

I think it was meant to introduce more than teach.

It does look that (not

It does look that (not surprisingly). Are there whole chapters online? I only saw excerpts.


Icon was not on the list. Perhaps you meant Io?

I wish someone would write a book of little quirky interesting languages that never really got anywhere, and have Icon in it.

The extracts are only the

The extracts are only the first few pages of a chapter.

Are the code examples complete?


Definitely intended as an introduction

Full disclosure: I was one of the technical reviewers for the book, and my book Debug It! is published by the same guys.

The average LtU reader is not the target market for this book. It provides an introduction to each of the seven languages - more than just "Hello World", but definitely not the whole of the language. It's far more about opening people's eyes to alternatives and providing a "flavour" of different approaches.

I'd bet that anyone reading this site has already had their eyes opened :-) But with luck, the book will sow seeds in a few fertile minds that will lead to them becoming LtU readers. And it's definitely a good book to have lying around in case you know someone who you think might be ready to break out of the Java monoculture.

But with luck, the book

But with luck, the book will sow seeds in a few fertile minds that will lead to them becoming LtU readers.

Just wondering, but does Bruce ever recommend in the book how to go about finding new languages and practices that I bet most LtU members do: joining mailing lists of the language as they learn it, etc.

Yes, absolutely. Bruce isn't

Yes, absolutely. Bruce isn't trying to "spoon-feed" the reader, but give them a taster, fire up their enthusiasm and point them at sources of more information.

But you see, that's the

But you see, that's the point. I am still unsure, after glancing at the excerpt, what he suggests is exciting about Prolog. I sure do know what I find exciting, and which examples I would have used had been the author..

The average LtU reader is

The average LtU reader is not the target market for this book.

Since this is the second time this type of claim has been made here recently, I will use this opportunity to say that I find it really annoying. I apologize in advance: Your message is perfectly fine, and doesn't deserve this wrath...

First, there is no such thing as an average LtU reader. (We are all above average here...) LtU was and is open to members with a wide range of skill levels. Many readers are "newbies" or beginners. The great thing here is that we don't segregate.

More to the point, I think that each of us was once a beginner, and still is when it comes to languages that are new to us. A C++ god may have a hard time understanding co-induction, and a type theorist may lack experience with the concerns of hard real time.

Last: Many of us have been teaching people about programming languages for years, either formally or informally. We have our opinions about what works, what doesn't (e.g., survey courses and books), which examples are worth discussing and which not, and so on. It is not a coincidence that we have a department devoted to material related to teaching and learning.

To sum up, I think we are capable of assessing the target audience of a book such as this, and offering meaningful opinions about it. So, sure, it is clear that this book is far more about opening people's eyes to alternatives. Whether it does this well or not, is something we may want to discuss.

I stand corrected, Ehud.

I stand corrected, Ehud. Apologies.

For the avoidance of doubt, I think it's an excellent book and one I'm delighted exists. I'm very jealous, in fact - I wish that I'd written it :-) (which is not to say that I agree with all of Bruce's opinions - my background and biases are different from his - but to worry about that would be to miss the point).

Thanks, that's helpful. Must

Thanks, that's helpful.

Must say I don't find the movie character idea charming (but then, who would?).

As a Reader

Actually, I thought his use of movie archetypes as metaphors for the essential character of the language worked pretty well and added wit to the lightning tours of the languages. While he does provide rudimentary syntax, the first exercise at the end of every day is to go out and find the documentation and tutorials for each language.

I'm not a sophisticated LtU reader, i.e., it doesn't take much for the mathematics to go over my head, but I do a fair amount of casual reading about languages and I thought he did an exemplary job of getting to the heart of how these languages feel. There are also discussions about object oriented versus functional programming and dynamic versus strong typing and concurrency issues which are described clearly in language suitable for a general interest reader.

My only disappointment: he didn't crack the Haskell/monad explanation problem. To his credit, he didn't punt the issue by saying it came from category theory. He certainly didn't pretend it was going to be easy.

I liken this book to a survey reference on art media, e.g., watercolors, oils, charcoal, pencil, pen and ink, sculpture, acrylics. No one will become an expert in all media, but I think a reader would get a good sense of essential techniques, their capabilities, and why different media are used.

A solid read

While it's not the best wide read on the market, I enjoyed it. Bruce summarizes each language clearly, and shows a number of solid examples of the interesting bits from each facet of the language. It's a light read for this audience, but still worth the price of the eBook IMO.

Now if you're looking for a deeper look into general language flow and design, I recommend Michael L. Scott's 'Programming Language Pragmatics'. It covers aspects of over forty different languages from the perspective of language design. I've read this one a number of times now, a text that has been instrumental in a number of DSL designs I've contributed to over the years.

PLP is certainly a good

PLP is certainly a good book, but it's very light on functional and logic programming. There is only one chapter devoted to both ideas. If one wanted to get a feeling for several different languages and programming paradigms the Seven Languages book might be a better way to accomplish this goal. Yet there is something to be said for introducing a language by looking at implementation details.

beyond Bruce Tate

As has been pointed out before: “Keeping up with events in the worlds of Messrs Eckel and Tate is going f-a-a-a-r beyond the call of duty.”

Thanks for digging these up!

Thanks for digging these up!

Beauty lies in the eye of the beholder

Beauty lies in the eye of the beholder, but what Tate calls “a beautiful example of method_missing in action” I would rather consider poor and ugly: Towards the end of the chapter on Ruby, he uses method_missing to encode the functionality of mapping from representations of Roman numerals to integers.

very interesting book so far

I have read up through the chapter on Ruby and I feel this book presents some of the most interesting features of Ruby and serves as a sort of a heads up on how you would proceed to program in Ruby. Imagine a book that sorted out the mundane aspects of a language leaving only its most interesting features and you have this book. While I couldn't build a Ruby application as of now, I would certainly know how to plan out doing so as I know the capabilities of the language. (The meta programming aspects of Ruby seem to be as important in application design as considerations of object orientation.)

You get out of it what you put in.

I'm in the middle of the book, and my impression is this: as with most books, if you put in the effort, you'll get something out of it. The difference is that it's much more obvious with this book that you need to do some extra legwork.

As others have pointed out, exercises include things like "go find and read the official documentation for this language"---a nontrivial assignment! Nevertheless, the book attempts to walk you through enough of the language so that one not-completely-trivial example of an idiosyncratic use of the language can be demonstrated.

In Ruby, for example, the author implements a class that, when included in another class, provides a method to populate the latter with methods for accessing CSV data stored in a file. The intent is to demonstrate that Ruby's metaprogramming facilities can be used to implement back door multiple inheritance.

Of the seven languages in the book, I came in proficient with Haskell and familiar with the semantics (but not syntax) of Prolog (having worked through The Reasoned Schemer). Sure, that meant the Haskell chapter was pretty much useless for me, but in a sense it gives me insight into the relative merit of the other chapters. In particular, it's clear that there's just not enough space to cover everything (as others have mentioned, Monads are completely skipped!), and the Haskell chapter is treated like a lesson in functional programming using Haskell syntax. Nevertheless, to someone who has no experience with FP, it's certainly exposure to something new and different.

The book is not particularly dense, which is good inasmuch as it makes for nice light reading; obviously this is at the cost of more comprehensive coverage of the material.

Overall, I think this book is worthwhile as a way of dipping your feet into a few different languages so that you can pick and choose which ones to explore further. Perhaps a better title would have been "seven programming paradigms in seven weeks," since the book serves more to teach about the paradigms than about the languages used in the teaching.