Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers) 1st Edition, Kindle Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Book recommendations, author interviews, editors' picks, and more. Read it now
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Customers who bought this item also bought
From the Publisher
|Seven Languages in Seven Weeks||Seven More Languages in Seven Weeks||Seven Databases in Seven Weeks||Seven Web Frameworks in Seven Weeks||Seven Concurrency Models in Seven Weeks||Seven Mobile Apps in Seven Weeks|
|Subtitle||A Pragmatic Guide to Learning Programming Languages||Languages That Are Shaping the Future||A Guide to Modern Databases and the NoSQL Movement||Adventures in Better Web Apps||When Threads Unravel||Native Apps, Multiple Platforms|
|Content Coverage||Clojure, Haskell, Io, Prolog, Scala, Erlang, and Ruby||Lua, Factor, Elixir, Elm, Julia, MiniKanren, and Idris||Redis, Neo4J, CouchDB, MongoDB, HBase, Postgres and DynamoDB||Sinatra, CanJS, AngularJS, Ring, Webmachine, Yesod, and Immutant||Threads & locks, functional programming, separating identity & state, actors, sequential processes, data parallelism, and the lambda architecture||iOS, Android, Windows, RubyMotion, React Native, and Xamarin|
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.--This text refers to the paperback edition.
""I have been programming for 25 years in a variety of hardware and software languages. After reading Seven Languages in Seven Weeks, I am starting to understand how to evaluate languages for their objective strengths and weaknesses. More importantly, I feel as if I could pick one of them to actually get some work done.""--Chris Kappler, Senior scientist Raytheon, BBN Technologies
""I spent most of my time as a computer sciences student saying I didn't want to be a software developer and then became one anyway. Seven Languages in Seven Weeks expanded my way of thinking about problems and reminded me what I love about programming.""--Travis Kaspar, Software engineer, Northrop Grumman
""Do you want seven kick starts into learning your "language of the year"? Do you want your thinking challenged about programming in general? Look no further than this book. I personally was taken back in time to my undergraduate computer science days, coasting through my programming languages survey course. The difference is that Bruce won't let you coast through this course! This isn't a leisurely read--you'll have to work this book. I believe you'll find it both mindblowing and intensely practical at the same time.""--Matt Stine Group leader, Research Application Development, St. Jude Children's Research Hospital --This text refers to the paperback edition.
- File Size : 1228 KB
- Publication Date : November 10, 2010
- Word Wise : Not Enabled
- Print Length : 330 pages
- Language: : English
- ASIN : B00AYQNR46
- Publisher : Pragmatic Bookshelf; 1st Edition (November 10, 2010)
- Screen Reader : Supported
- Enhanced Typesetting : Enabled
- Simultaneous Device Usage : Unlimited
- Text-to-Speech : Enabled
- X-Ray : Not Enabled
- Lending : Not Enabled
- Best Sellers Rank: #434,555 in Kindle Store (See Top 100 in Kindle Store)
- Customer Reviews:
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
By reading this book you will not become an expert in any of the languages. The book is more like introduction to each language. Imagine you searched on Google for "Differences between Scala & Ruby". You would get the Wikipedia entry and maybe a blog post or two. This book is sort of like a really long blog post about the different languages.
Bridging across chapters, the author looks often at the concurrency model each language has along with other aspects.
It's not a perfect book though. Because the book is roughly 300 pages the coverage can be light, and clearly the author is not an expert in all 7 languages; but at least he does not claim to be... the author is generally humble throughout the book.
This was the right book for me at the time, because I read it as I was getting back into software development. I wanted to know what had changed in programming as well, and it improved my knowledge.
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.
- 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.
The approach is at least a half-way decent one: introduce a language, give three days worth of lessons (plus homework) and then use that to bridge into the next language/style.
But it also comes across as very surface-level. 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).
Top reviews from other countries
These concepts include side-effect-free functional programming, and how that helps concurrency. Most of the languages have support for the actor model of concurrency. There is also a language that uses prototyping, the description of which makes me think this is a recipe for something much worse than spaghetti. Erlang’s "let it crash" feature is most interesting of all: a concurrent language combining monitoring code, and restarts, allows for a different approach to achieving robust code: rather than lots of defensive programming and exception handling, just watch for crashes, and start the objects up again when they fall over.
If you do want to do the hard work, you will need much more than this book. Tate overviews the concepts, sets the problems, and points you off to the web to get the detailed information you need for the tasks. I assume doing the work does reap the rewards: where code is concerned, doing is better than reading. But I prefer doing tasks that solve problems I want to solve, rather than exercises.
The style is brisk and to the point, mostly. I could have done without all the analogies to movies I mostly haven’t seen. But if you want to learn about some fundamental programming principles, and how they occur in a range of programming languages, this book will give you a good head start.
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.
Unfortunately many languages are recent and have fast growth, turning the presented versions in the book a bit old (but nothing unbearable).
The worst point in my opinion is that the book starts focusing much in the same features (pattern matching, partial functions, high order functions..) and the exercises begin to look as the author had some lack of attention as it are not as interesting as the first ones.