Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers) [Paperback]

Bruce A. Tate (Author)

Book Description

Publication Date: November 17, 2010 | Series: Pragmatic Programmers

You should learn a programming language every year, as recommended by The Pragmatic Programmer. But if one per year is good, how about Seven Languages in Seven Weeks? In this book you'll get a hands-on tour of Clojure, Haskell, Io, Prolog, Scala, Erlang, and Ruby. Whether or not your favorite language is on that list, you'll broaden your perspective of programming by examining these languages side-by-side. You'll learn something new from each, and best of all, you'll learn how to learn a language quickly.

Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell. With Seven Languages in Seven Weeks, by Bruce A. Tate, you'll go beyond the syntax-and beyond the 20-minute tutorial you'll find someplace online. This book has an audacious goal: to present a meaningful exploration of seven languages within a single book. Rather than serve as a complete reference or installation guide, Seven Languages hits what's essential and unique about each language. Moreover, this approach will help teach you how to grok new languages.

For each language, you'll solve a nontrivial problem, using techniques that show off the language's most important features. As the book proceeds, you'll discover the strengths and weaknesses of the languages, while dissecting the process of learning languages quickly--for example, finding the typing and programming models, decision structures, and how you interact with them.

Among this group of seven, you'll explore the most critical programming models of our time. Learn the dynamic typing that makes Ruby, Python, and Perl so flexible and compelling. Understand the underlying prototype system that's at the heart of JavaScript. See how pattern matching in Prolog shaped the development of Scala and Erlang. Discover how pure functional programming in Haskell is different from the Lisp family of languages, including Clojure.

Explore the concurrency techniques that are quickly becoming the backbone of a new generation of Internet applications. Find out how to use Erlang's let-it-crash philosophy for building fault-tolerant systems. Understand the actor model that drives concurrency design in Io and Scala. Learn how Clojure uses versioning to solve some of the most difficult concurrency problems.

It's all here, all in one place. Use the concepts from one language to find creative solutions in another-or discover a language that may become one of your favorites.

Editorial Reviews

About the Author

Bruce Tate runs RapidRed, an Austin, TX-based practice that consults on lightweight development in Ruby. Previously he worked at IBM in roles ranging from a database systems programmer to Java consultant. He left IBM to work for several startups in roles ranging from Client Solutions Director to CTO. He speaks internationally and is the author of more than ten books, including From Java to Ruby, Deploying Rails Applications, the best-selling Bitter series, Beyond Java, and the Jolt-winning Better, Faster, Lighter Java.

Product Details

• Paperback: 328 pages
• Publisher: Pragmatic Bookshelf; 1 edition (November 17, 2010)
• Language: English
• ISBN-10: 193435659X
• ISBN-13: 978-1934356593
• Product Dimensions: 7.5 x 1.5 x 8.9 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 4.3 out of 5 stars  See all reviews (34 customer reviews)
• Amazon Best Sellers Rank: #53,792 in Books (See Top 100 in Books)
  • #89 in Books > Computers & Technology > Programming > Introductory & Beginning

More About the Author

I started in this industry back in 1985, as a co-op with IBM in Austin. I joined IBM full time in 1987, and spent 13 years with them. I later left to join a startup, and ultimately started my own business where I focus on helping customers build software with lightweight technologies.

I've been writing technical books for more than 10 years now, with the last 7 coming since 2000. I write for the love of the craft.

Others have told me that my fundamental strength as an author is the ability to quickly recognize emerging trends. I do tend to find emerging frameworks just as they become popular, and that skill is a mixed blessing that--combined with my complete lack of political tact--gets me in trouble sometimes, as it did with Bitter Java (Java is too hard), Beyond Java (Java is not going to last forever), and most recently, From Java to Ruby: Things Every Manager should Know (there's a better language for some problems, but our managers don't know it yet.)

My promise to you is this: I will always seek to find better ways to do things, and will work hard to tell you the truth, without regard for any notion of political correctness. Thanks for reading.

Most Helpful Customer Reviews

172 of 176 people found the following review helpful

4.0 out of 5 stars Much (perhaps over) anticipated November 8, 2010

By MedIT VINE™ VOICE

Format:Paperback|Amazon Verified Purchase

Background: I stumbled across the author's blog post announcing his intention to write the book while looking for materials comparing language paradigms instead of particular languages (object-oriented, logical, functional, prototype, etc). The as yet unwritten book sounded like exactly what I was after (thus my enthusiastic anticipation). I purchased an electronic copy of this book from the Prag Press beta program about six months ago and began reading the chapters as they were completed and released. My paper copy just arrived from Amazon today. Thus I can comment on the whole content of the book and the physical object.

Languages: While the languages covered (Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell) are excitingly (painfully?) trendy the list is not without merit. In the introduction the author explains that he arrived at the list by asking readers and edited from there: swapping Io for JavaScript and excluding Python thereby making room for Prolog. One could debate the choice of Io over JavaScript (particularly in a post Node.js / Common.js world) and make a case for including Smalltalk as the canonical OO language over Ruby; however, the chosen languages each bring something to the book and represent a number of interesting paradigms.

Chapters: Each language has its own chapter. Each chapter has five sections:
- an introduction to the language covering topics like it's history, place in the modern language landscape, paradigm, etc
- 'Day 1'
- 'Day 2'
- 'Day 3'
- and a conclusion with a few parting words / 'the moral of the story is...'.
The boundaries between days are not particularly meaningful but roughly build from "here's the syntax" to "here's an interesting thing you can do with this paradigm". By Day 3 each chapter has moved beyond trivial "hello world" examples; not surprisingly then, the pace of progress is brisk and the details of how to get up and running with each language are largely left to the reader.
Each language chapter includes an interview with a user/creator of the language (Matz, Steve Dekorte, Brian Tarbox, Martin Odersky, Joe Armstrong, Rich Hickey, Philip Wadler / Simon Peyton-Jones). These were an unexpected addition and quite worth reading. In fact, I wish the interviews had been longer and gone into more technical detail.
In addition to the seven language chapters there is an introductory chapter that has the sort of information normally found in the pre-page-numbering introduction to a book (explanation of the book's contents, intended audience etc) and an excellent final wrap-up chapter (more on it later).

Length: I easily completed each language chapter in a weekend. The first and last chapters are very quick reads. Seven weeks should be more than enough time to work through the book.

Subjective annoyances:
- The quality of the physical book (not great) will be familiar to regular Prag Programmer shoppers. It is not up to O'Reilly standards (it's more like an Apress book). Although the typesetting is easy to read the top and bottom margins are unpleasantly tight. The outside margin leaves room for notes which I like, but the book is awkwardly square. For $22 what does one expect?
- Each chapter attempts creativity with a supposedly allegorical popular culture reference threaded through it (ex: Io = Ferris Bueller). I found these more distracting than informative. I'd include naming the chapter sections "day n" as similarly failed attempts and wish that instead attempting wit (ex Io Day1: An Excellent Driver) they had substantive names. Obviously this is totally personal opinion, you might like it.

Outright Disappointment: I wish that the individual chapters went into significantly more depth comparing the motivations for and consequences of each language design. While the key features of each language are demonstrated with annotated code samples and explanatory text little is offered in the way of discussion comparing across language. For example the Scala chapter (selected at random) is on pages 121-166 in the index under "Scala" the only references outside its own chapter are found on pages 302, 303, 305-306, and 308 (all in the final wrap-up chapter). I view this as a real missed opportunity given the books unique approach/content. The final wrap-up chapter seems to be the only place with this sort of cross-language discussion and as a result it is both excellent and much too short.

Conclusion: An interesting book that I enjoyed reading and expect to return to in the future. The physical book is of so-so quality and as such the electronic book may be the right product for you to buy. The missed opportunity (and loss star) are for a disappointing failure to draw cross-language comparisons within the text of each chapter.

----------
Update: [...]is a 45 min talk on the book / topics in the book.

34 of 38 people found the following review helpful

2.0 out of 5 stars Too shallow to be interesting June 25, 2011

By Brian L.

Format:Paperback

I was very disappointed in this book. I could have attain a similar level of depth with fewer unnecessary film-based analogies by reading each langauges' wikipedia page.

The author focuses heavily on syntax, program structure, and how common things are represented in each language, what the REPL, looks like in each case, etc. There many belabored explanations of well-understood language-agnostic concepts like prototypes, actors, futures, recursion, laziness, and immutability. Zero of these languages are interesting because of how lists work yet the book laboriously visits this example over and over. Similarly, only one or two of the languages has truly interesting things to say about concurrency, but he discusses concurrency over and over.

Each of these languages has made important contributions to the field of programming language design and culture. This is where the time should be spent--not developing a familiarity with basics like syntax and list operations. If I want to know what the code is going to look like visually, I can use wikipedia.

For instance, a core idea behind prolog is unification. The author gives lots of examples of prolog code, but fails to explain at any level of detail the theoretical basis for unification or how it works. I don't have a prolog background, and when I sat down to read the chapter, I hoped to come away with a basic working understanding of the concepts. All I ended up with is some ideas of how prolog is used and what it feels like at the surface of its syntax/semantics.

One of the most interesting things in Io is the combination of an unusually transparent message-passing discipline with a mutable syntax tree. In Io, you can build messages that serve as macros--mutating their call-site at the first invocation in order to generate code, accomplish call-by-name semantics, or do any number of other interesting things. These patterns exist throughout the standard library, and at least when I was participating in the Io community more actively, were one of the most frequent topics of discussion. This stuff is really, really cool, and the author didn't do it justice, instead spending time explaining basic ideas like actors and prototypes as if Io is extremely unique for having them.

Ruby is actually fairly boring as a programming language in and of itself. It's largely a reboot of smalltalk semantics into the clothing of a scripting language. Hardly a great innovation. However, the ruby community has developed an awesome culture--a culture that is certainly informed by ruby itself, but is not at all inherent to it. Even though ruby stopped being an everyday language for me several years ago, the lessons I learned from its culture continue to influence my work in other languages. The author should have spent time discussing this culture and how culture contributes to ruby's success instead of belaboring the basics of syntax or explaining ruby's unimpressive module system or its approach to concurrency.

Instead of focusing on the beauty in these systems, the author opted to do something far more boring--write a collection of shallow tutorials.

Finally, I was disappointed that the author neglected to include any languages suitable for high-performance computing or systems programming. This might have included Go or D.

I'm not sure who this book is good for. I didn't get much out of it, and despite my vast appreciation for the contributions of these languages, I felt that the book didn't do them justice, instead opting to focus on basics and trivialities. My advice is to skip it. Maybe someone will do this concept well someday, but this book isn't it.

53 of 62 people found the following review helpful

3.0 out of 5 stars Not interested in the merchandise March 17, 2011

By Dmitry Dvoinikov

Format:Paperback

The idea is good - have a brief overview of several programming languages that gather most curiosity in the community. The languages that made it to the book were chosen by the people the author asked beforehand.

Each language is given 3 days worth of chapters. First day is for a = b, second is for [a] = [b] and the third is for "real stuff". About two thirds of the book are therefore dedicated to simple variable assignments, number literals, containers (lists mostly), and control structures such as if's.

And herein lies the problem - although great to know that in language X assignment goes like

console> plz let a be 1
a nowz 1!!!oneone
console>

but what does it tell about the language ?

---QUOTE---
I'm confident that this material will capture the spirit of each programming language pretty well...
---/QUOTE---

I don't think it happened. It would be possible if the author had spent years working in each one. This is not the case, the author had learned the languages himself, took a bite and now explains the fullness and richness of taste. There is no trick here, the author is not pretending he is an expert in everything. All this is clearly admitted upfront. On the other hand a lot is required from the reader too. You are expected to give each individual language a try. Otherwise

---QUOTE---
If you simply read this book, you'll experience the flavour of the syntax and no more.
---/QUOTE---

Exactly what happened to me. None of the seven languages made me curious because of this book. I was curious about erlang before and I still am. I saw something beautiful behind haskell and I still do. The languages I haven't seen before, I'm as unsure about now as I was before.

The book doesn't answer the real questions. You will not *learn* any of the languages. It is at most a bait for a curious programmer having one of his "oh ! interesting !" moments.

I'd recommend this book for someone who is dying to get his hands dirty in just any language but is unsure which one to pick.