Learn more Download now Shop now Learn more Shop now Shop now Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Shop now Shop now Learn more Shop Fire Shop Kindle Ed Sheeran Shop now Shop now


HALL OF FAMETOP 50 REVIEWERon 13 October 2016
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.
0Comment| One person found this helpful. Was this review helpful to you? Report abuse
on 20 January 2011
Okay, I've given this 5 stars which is high praise but needs some qualification: probably best just to say what this book is NOT, first, and then what it IS and why it succeeds so well.

Firstly, I would take the "Seven weeks" with a pinch of salt: this isn't really a "learn Mython in 21 days" type book - with little lessons that lead at the end to being able to program in Mython. If you want to learn, say, Haskell, there are better books for that available from this very web site. And therefore you certainly won't be an expert in SEVEN languages when you've worked through this book either (i deliberately say "work through" as this is a very hands-on book).

So without out the way, I'll say what the book is and why i love it so much.
This is a book that is good if you want to more than dip your toes into a language - as Mr Tate says "I won't make you an expert, but I'll teach you more than 'Hello World' ". The amount of effort put into this tome seems phenomenal: ("This is the most demanding book I have ever written."). Not satisfied with teaching you loads about the languages (and some of these were not the author's area of expertise, he had to learn the languages himself!) he somehow found time to look into the history of the languages (an interesting subject in itself) and ALSO interview many of the key people involved in creating the languages!. The "why did you make this language" interviews are fascinating reading.

I also love Mr Tate's style- it's quite 'light' (but not as light as the "Head First" style)- you don't feel like you're reading a textbook at all, and despite the fact that some of it can get very technical, this book never feels like heavy reading: part of it is due to the fact that he has a tv/movie theme running through each language: for Ruby, the theme is Mary Poppins, and for Erlang it's The Matrix- he uses these themes to highlight the different characters of the languages, and I've never seen it done anywhere else (not to this extent anyway) but it does work, and I found the connections really amusing.

"So it's a pleasant to read, deeply researched book, but what about the languages?", I hear you ask.
Okay, in the 309 jam-packed pages Mr Tate will introduce you to, and see you through a converstion with:
Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell.
It's a fairly steep learning curve: this is NOT a "how to program" or "how to install" software book; but it does get you doing some fairly intense stuff fairly quickly - even if you don't do all the examples you come away knowing enough about each language to know if you want to explore it further.
Also, even if like me you're aware of some of the languages (i already knew about Haskell and Prolog) and don't want to read those parts, there's so much about the other languages, that it's still worth the money, but I would say that: it's after using this book I am now in love with Ruby, Clojure and Scala - otherwise I might not have come across those for ages - so of course I am biased: this book quite literally changed my coding life!

So to summarise: if you're interested in programming languages per se, rather than just programming in general, and getting bored with Java/C and want more than a superficial look at some other fascinating languages out there then this is an excellent book to start your coding adventure.
Alan
0Comment| 76 people found this helpful. Was this review helpful to you? Report abuse
on 19 September 2016
good book
0Comment|Was this review helpful to you? Report abuse
on 28 June 2012
In this book, Bruce gives the reader a grand tour of several very different programming paradigms, ranging from dynamic and prototyped languages to logic based, minimalistic, functional and other exotic paradigms. As a reader you get a glimpse of what programming is like in other "worlds", and you will get inspired to try out new languages, or perhaps to adapt exciting new features into you own language of choice. I would recommend any developer who has spend some years in the same programming language to read this book, if nothing else just for sheer inspiration.
0Comment| 4 people found this helpful. Was this review helpful to you? Report abuse
on 30 May 2011
I had a quick flick and thought this sounds exactly as described... went to the pub for yet another leaving drink. End of the night my book was gone :-( What better recommendation is there?
0Comment| 7 people found this helpful. Was this review helpful to you? Report abuse
on 21 April 2012
That's one of the books that I fell in love with. A tour de force on various programming paradigms. After that you'll be expert in none of the languages/paradigms presented (most possibly you won't even remember the specifics of most of them) but you'll feel MUCH richer as a professional and as a human.

Writter is speaking like a good friend you got out with for a coffee and that's the feeling of the whole book.
0Comment| 3 people found this helpful. Was this review helpful to you? Report abuse
on 19 March 2015
Excellent book for being introduced to several programming languages, each with a particular set of implementation decisions. It makes you see the differences and, even better, makes you understand the implication of each language design decision.

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.
0Comment|Was this review helpful to you? Report abuse
on 17 May 2015
An engaging overview of advanced programming languages from a very high perspective, with more stress of philosophy than actual usage. The book covers Ruby, Io, Erlang, Prolog, Scala, Clojure and Haskell. I appreciate the chapter about Io the most - a completely unknown languge to me until now, yet so clean and singular.
0Comment|Was this review helpful to you? Report abuse
on 19 July 2012
I enjoyed this book greatly. I was a (poor) programmer long ago (Algol, the Fortrans, Basic, APL (remember - the "write-only" language?), Pascal and one running COBOL program!, and this book brought me upto date with current paradigms - though as B A Tate remarks, the paradigms change very slowly and I was only a generation and a half or so out of date. I so liked the book I've loaded Haskell on one of my machines and have bought Miran Lipovaca 's remarkable Learn You a Haskell for Great Good.
0Comment| 2 people found this helpful. Was this review helpful to you? Report abuse
on 13 April 2011
Very inspiring read again from the Pragmatic Programmers.
I had looked into a couple of the presented languages before, but the introduction in this book gave me quite a new view of them. Very valuable summary of when, where and how to use the languages.
0Comment| 2 people found this helpful. Was this review helpful to you? Report abuse



Need customer service? Click here

Sponsored Links

  (What is this?)