Enjoy fast, FREE delivery, exclusive deals and award-winning movies & TV shows with Prime
Try Prime
and start saving today with Fast, FREE Delivery
Amazon Prime includes:
Fast, FREE Delivery is available to Prime members. To join, select "Try Amazon Prime and start saving today with Fast, FREE Delivery" below the Add to Cart button.
Amazon Prime members enjoy:- Cardmembers earn 5% Back at Amazon.com with a Prime Credit Card.
- Unlimited Free Two-Day Delivery
- Instant streaming of thousands of movies and TV episodes with Prime Video
- A Kindle book to borrow for free each month - with no due dates
- Listen to over 2 million songs and hundreds of playlists
- Unlimited photo storage with anywhere access
Important: Your credit card will NOT be charged when you start your free trial or if you cancel during the trial period. If you're happy with Amazon Prime, do nothing. At the end of the free trial, your membership will automatically upgrade to a monthly membership.
Buy new:
$17.09$17.09
FREE delivery: Wednesday, June 21 on orders over $25.00 shipped by Amazon.
Ships from: Amazon.com Sold by: Amazon.com
Buy used: $10.32
Other Sellers on Amazon
+ $3.99 shipping
98% positive over last 12 months
& FREE Shipping
94% positive over last 12 months
& FREE Shipping
82% positive over last 12 months
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required. Learn more
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers) 1st Edition
| Price | New from | Used from |
- Kindle
$16.24 Read with Our Free App - Paperback
$10.32 - $17.09Other new and used from $1.97
-
90 days FREE Amazon Music. Terms apply.
90 days FREE of Amazon Music Unlimited. Offer included with purchase. Only for new subscribers who have not received offer in last 90 days. Renews automatically. You will receive an email to redeem. Terms apply. Offered by Amazon.com. Here's how (restrictions apply)
Purchase options and add-ons
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.
- ISBN-10193435659X
- ISBN-13978-1934356593
- Edition1st
- PublisherPragmatic Bookshelf
- Publication dateNovember 30, 2010
- LanguageEnglish
- Dimensions7.5 x 1.2 x 9.25 inches
- Print length330 pages
Frequently bought together

What do customers buy after viewing this item?
- Lowest Pricein this set of productsThis item:
Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages (Pragmatic Programmers)Paperback - Most purchased | Highest ratedin this set of products
Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable SystemsPaperback
Special offers and product promotions
- Get 3 for the price of 2. Offered by Amazon.com Shop items
- 90 days FREE of Amazon Music Unlimited. Offer included with purchase. Only for new subscribers who have not received offer in last 90 days. Renews automatically. You will receive an email to redeem. Terms apply. Offered by Amazon.com. Here's how (restrictions apply)
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 |
Editorial Reviews
Review
""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
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
- Publisher : Pragmatic Bookshelf; 1st edition (November 30, 2010)
- Language : English
- Paperback : 330 pages
- ISBN-10 : 193435659X
- ISBN-13 : 978-1934356593
- Item Weight : 1.51 pounds
- Dimensions : 7.5 x 1.2 x 9.25 inches
- Best Sellers Rank: #253,621 in Books (See Top 100 in Books)
- #301 in Introductory & Beginning Programming
- #315 in Software Development (Books)
- #672 in Programming Languages (Books)
- Customer Reviews:
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.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
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.
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.
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.












