Seven Languages in Seven Weeks

I find this book to be a lot like "Programming Collective Intelligence" in that it introduces you to new concepts for even experienced developers. You're expected to know a lot about programming already, but as it's introducing new concepts, it gives you enough background to follow along, but not so much detail that you're bored. It also has a couple of different sections for each language, including short interviews with the language designers. You can learn ruby anywhere, but it's going to take you a while to find out what makes it unique, whereas this book gets right to what's important, with no boringness. You can get through one language a day, or faster if you don't bother trying to do the examples or questions, but those were well-chosen. The book is a little too playful at times (describing Ruby as like Mary Poppins), but it's entertaining and makes it less dry (ex. in a description of a possible mistake someone might make when programming Io it states "If that line of code is buried deeply into a complex package, Io just puked in your car.").

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.

Bruce Tate does an amazing job cutting to the heart of what makes seven programming languages special in about 50 pages each. He is also pretty honest about the limitations of each. I had a great time working through the seven chapters and learned a lot. At the start of each chapter, you have to figure out how to download and install a compiler/interpreter for your os. The book does not cover that part of the process which is fair enough. Then, each chapter contains a series of simple, complete, well-paced examples. Type them in, and be amazed how much you learn in 50 pages. This book is not (and never claims to be) a comprehensive introduction to any of the languages. In some sense it is better as it shows the strength of each, almost like an advertisement. He is trying to get you excited about each language. Going into this book, I had some familiarity with Ruby and Haskell but knew virtually nothing about any of the other five. On the two languages I had used before, those chapters were solid and I even learned a few things. Of the other five, Tate did his job and got me excited about Io. Since reading that chapter, I have been diving in to Io. The others were interesting, but Io caught my attention. The book is a little heavy on the functional languages: Erlang, Scala, and Haskell. Given that I am already Haskell fan, the Erlang and Scala chapters felt like a missed opportunity to me. Of course, everyone who reads the book would probably want a different list of seven.

I like the book, but it is not the alternative modern-day undergrad textbook for Programming Languages (PL) that I was seeking. It is inexpensive and it encourages a hands-on treatment of PL concepts across several language paradigms. However, its coverage of PL concepts is incomplete and the languages (Io, Scala, Erlang, Clojure, Haskell, Prolog, Ruby) will be unfamiliar to most who are not CS professionals or who are unfamiliar with ACM/SIGPLAN. So I am still looking for the PL "textbook" that includes several popular languages from the Info/Web Tech industry (e.g., JavaScript, PHP, Python, HTML5) as a way to introduce some PL terminology and make comparisons with less familiar languages/paradigms. So this was not the book to do that. None the less, I like this book and I recommend it to other computing professionals. I see this as a textbook for the computing professional to use for "continuing ed" to expand their horizons as software developers. The author's writing style is first person and conversational. He illustrates a selection of features and syntax that is specific to each language using code clips and narrative text about it. There are not many illustrative diagrams or figures. Each chapter that covers one of the languages is best read from beginning to end since it is written in tutorial sequence rather than in "reference" style. The author likes to use movie references as metaphors, which for me were more distracting. The coding examples throughout are good. I liked those for Prolog which included a Sudoku program. The coverage for each language includes an interview-dialog with an expert or inventor of the language (which further contributes to the textual/conversational style). PL terminology is encountered and defined throughout and the index is helpful for finding them, but this is not the definitive text for programming language terms and definitions (e.g., Scoping is not mentioned and several terms are defined mostly by example). The author offers minimal guidance on how to get started (download/installation) with these languages. A companion web site for this book would be nice, especially if it provided details regarding downloads, installation, setup, and use of the development tools available (even at the risk of becoming outdated). But that can easily be found online, as the author points out. Once again, I am glad I purchased the text.

Order was received on time. No issues with this order.

In a way, it's almost as if this book (and the subsequent book with seven more languages) was written specifically for me...except for the "seven weeks" part. I have an erratic schedule, so staying with the day-by-day pattern didn't work for me. Nevertheless, the choice of languages was very helpful for me, personally (as always, other readers will likely disagree). The chapter on Ruby was a nice introduction to a language I'd seen mentioned a lot of times, but knew very little about it. Io was relatively uninteresting, but did help explain how a similar language, JavaScript, works. Prolog was fascinating, albeit limited, and is the oldest language described in this book. Scala is a language I had wanted to check out, anyway. Erlang is interesting (the "let it crash" philosophy was particularly intriguing). Clojure and Haskell were languages I'd already started studying on my own, and even though I've done a modest amount of Clojure learning, this book's superficial coverage of that language was still very helpful (perhaps the author included more relevant information about Clojure?). The focus of the book is on the progress of computer programming languages, and this is summarized nicely in the final chapter. I liked how each language chapter ended with a description of the strengths and weaknesses of each language. The only significant problem is that the book was written in 2010, so a few parts seem a bit out of date. Also, there are a few minor omissions in the book...so it's helpful to visit the publisher's website to view the forum there.

Pragmatic Programmers just released the first draft of Seven More Languages in Seven Weeks, written by Tate and a few others, and I found myself downloading this rather than digging my paper copy out of storage. Coming back to it, I was amazed at how much I remembered and how much I had forgotten. But the one thing that has stuck with me is thinking through different ways of thinking things through. For most of the languages in this book, I saw how they worked, did the easier exercises and called it good. But I was left intrigued by Erlang and worked through Simon St. Laurent's Introducing Erlang even though I have no need of the language. Fast forward a year and I'm learning R to sort through company data more easily and all of a sudden a functional mindset is extremely valuable for me to have. Coming from the dark ages when amateurs wrote everything in BASIC and done a little bit of C++, Java and Javascript, I would have been lost without my Erlang background. Seven Languages in Seven Weeks was written to stretch your brain and show you that assumptions about programming based on the language you use most can limit you while learning new languages gives you new ways even to use old languages. For me, it's a winner. I learned a language I've never used in real life since, but had I not done so, I would have been baffled by a language (R) that I've been learning and using for the last year or so. I highly recommend this for anyone who has to solve problems on a computer but keeps turning to the same tricks for the same problems instead of breaking new ground.

First of all, 1 week is not enough time to attain any kind of mastery in a language, much less to do so with Haskell, Prolog, or Erlang. It is enough to get some basic syntax and cursory knowledge in. But what I like about this book, and this series is the 'distillation' of knowledge of key concepts in the language and presenting it in a fashion that is comfortable for a developer to understand. Information about this language is out there, but a language is more than syntax and semantics, it is about a frame of mind. So go ahead and get this book and be prepared to be shot forward into infinity.

very good book.

Recomendada lectura para programadores expertos y principiantes. Te enseña distintos paradigmas de programacion y aprendes a comprender más rápido como funciona todo

Ich habe das Buch, anders als der Autor vorschlägt, nicht gelesen und währenddessen die Programmierbeispiele praktisch ausprobiert (außer bei der ersten beschriebenen Sprache Ruby), sondern direkt runtergelesen, weil ich lediglich einen tieferen Einstieg in (aktuelle) Entwicklungen der verschiedenen Programmierparadigmen (Objektorientierung, funktional, logisch, Prototype) bekommen wollte, ohne diese praktisch anzuwenden. Und dafür ist das Buch wirklich super! Bruce Tate zeigt anhand von sinnvollen Praxisbeispielen mit sehr vielen Quelltextauszügen die Vor- und Nachteile der einzelnen Sprachen (Ruby, Io, Prolog, Scala, Erlang, Clojure und Haskell) auf und geht insbesondere auf die jeweiligen Vorzüge ein, die das Programmieren einfacher machen ("syntactic sugar"). Für alle, die die Sprachen auch in der Praxis ausprobieren wollen, liefert Tate nach jedem Kapitel Online-Quellen und Tipps für interessante Miniprojekte. Dabei folgt er einem sehr sinnvollen Aufbau. Bei den ersten behandelten Sprachen werden allgemeingültige Konzepte von Programmiersprachen eingeführt und anhand von Beispielen erklärt (z.B. Pattern Matching, Rekursion, Closures, Futures) und bei den Sprachen im hinteren Teil des Buches wieder aufgegriffen und vertieft. Dabei streift Tate wirklich viele aktuelle Entwicklungen insbesondere aus dem Bereich der funktionalen Sprachen: 5 der 7 Sprachen sind entweder komplett oder in Teilen funktional. Ich kannte bislang von den vorgestellten Sprachen lediglich Prolog, sodass mir das Kapitel hierzu als kleine Auffrischung meiner Kenntnisse diente. Ich war überrascht, wie viele (hilfreiche) Konzepte es aus Prolog inzwischen in andere Programmiersprachen geschafft haben. Für Anfänger ist das Buch wohl eher schwierig zu verstehen, da nicht lange gefackelt wird und viele grundlegende Kenntnisse vorausgesetzt werden. Für fortgeschrittene Programmierer, insbesondere aus dem Bereich der Objektorientierung, ist es jedoch ein super Buch, um einmal über den Tellerrand zu schauen. Gerade heutzutage, wo die funktionalen Sprachen immer wichtiger werden (aufgrund der guten Parallelisierbarkeit), sollte jeder Entwickler einen Blick riskieren und schauen, welche Konzepte er für seine eigene Arbeit übernehmen kann. Durch die Vielzahl an unterschiedlichen Sprachen wird das Buch definitiv nicht langweilig und man kann es richtig verschlingen.

This is one of my favourite programming books. It's also one of the books which has had a profound influence on me. I've read it cover to cover several times now. I've been programming for many years, and have also managed developers and teams of developers. But I've mostly programmed in C, C++, and Java (plus managed developers of the same). This book has opened my eyes to what else is available. On the first reading, I loved Ruby, quite liked Io, hated Prolog, liked Scala, quite liked Erlang, loved Clojure, absolutely hated Haskell. I bought Scala and Erlang books, coded a bit, and read loads of stuff on the web. On the second reading, I skipped Ruby (too much like good old C/C++/Java, although highly productive), didn't like Io, loved Prolog (amazing how it can solve a Sudoku puzzle on its own, just by telling it the rules), began to go off Scala (high gravitational pull from Java), loved Erlang, liked Clojure, and Haskell started to grow on me. As an aside - about this time I inherited a team which was working on an app which had been ported to Clojure, followed by the Clojure developers moving on. The remaining developers thought that their career had stalled, and they wanted to get back to the mainstream (Java). We found it almost impossible to hire Clojure developers. Please don't berate me on this - I like Clojure and its ethos, and the story says more about large IT departments than it does about Clojure. All of this Clojure, Erlang, and Haskell was getting me into functional programming. As a manager I'd been concerned about how we could get best value out of modern multi-core servers, and solve the seemingly intractable problem of how to code multi-threaded software in a reliable and developer-efficient way. Functional programming seemed to give some hope - especially Erlang. I read several Erlang books, and Joe Armstrong's (one of the designers of Erlang) PhD thesis. I bought and read Bratko's Prolog book, and even "Real World Haskell". Erlang is my absolute favourite language (and I like its syntax, so no great temptation to move to Elixir). Given its close relationship with Prolog, I need to get more into Prolog too. And Haskell has become a friend. I suspect I may end up being a Haskell developer. All this has been triggered by "Seven Languages in Seven Weeks". Thank you, Mr. Tate.

A proposta do livro é dar uma visão geral de 7 linguagens de programação atuais. As linguagens envolvem diferentes paradigmas e conceitos. Claro que não há aprofundamento, mas é ótimo para quem quer ter uma noção rápida e prática.