Customer Reviews: Eloquent Ruby (Addison-Wesley Professional Ruby)
Your Garage Buy 2 kids' books and save Amazon Fashion Learn more nav_sap_plcc_ascpsc $5 Albums Fire TV Stick Happy Belly Coffee Totes Summer-Event-Garden Amazon Cash Back Offer DrThorne DrThorne DrThorne  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Introducing new colors All-New Kindle Oasis Shop Now STEM

Format: Paperback|Change
Price:$38.63+ Free shipping with Amazon Prime
Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on February 26, 2011
This book is so easy to read yet so useful and informative that I read it in its entirety within 24 hours (across 2 distinct days admittedly ;-)).

Eloquent Ruby is a book published by Addison Wesley and written by Russ Olsen (who also wrote Design Patterns in Ruby a few years ago). It clocks in at around 400 pages and has 31 chapters clocking in at around a punchy 10 pages each. Each chapter is titled as a guideline you should follow to write "eloquent" Ruby - things like Create Classes That Understand Equality and Write Code That Looks Like Ruby - and typically the claim is explained, some code examples shown and discussed, some real world examples pointed to, and that's it. As with Design Patterns in Ruby, Russ adopts a chatty, familiar tone. Reading this book is like reading a book specifically written for you by a friend. He doesn't shoot off on many unnecessary tangents and he keeps the stories short and sweet but this book certainly couldn't be called dry.

The book is also notably short of egregious errors or omissions. Even when I don't read something with a fine-toothed comb on standby, I can usually pick out a laundry list of factual and grammatical errors or omissions (as both Obie Fernandez and my wife will attest) but Eloquent Ruby gave me little to chew on. I can only bring to mind a few spacing and formatting issues and only one true "error": a > instead of a < in a class definition on a single example.

Russ tries to remain neutral with his choice of Ruby implementations but the book seems to focus primarily on Ruby 1.9 (Ruby 1.9.1 specifically but that's just due to when he wrote it) while providing useful footnotes in the cases where there are differences to Ruby 1.8. No matter what Ruby implementation you're using, there's little to confuse you as most of it is very non-implementation and non-version specific.

I wholeheartedly recommend this book to anyone except those who, well, could have written a similar book themselves. The short punchy chapters make it a delight to read and gives the option of reading it merely 10 minutes at a time before bed or similar. The short chapters also make it useful as a reference if you forget how to do a certain thing like, say, use method_missing, even though it's not put together as a reference book at all. Lastly, this book is a must read if you're not confident with Ruby idioms and the best way to structure and lay out your code - Russ's approaches reinforce the current "standard" way to write Ruby and this alone is worth the price of admission.
0Comment| 70 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 7, 2011
For better or worse the vast majority of my work life journey has been travelled with Java as my vehicle of expression. However, by nature I have a burning desire to learn new languages and at one point or another I discovered Russ Olsen's (also the author of Eloquent Ruby) "Design Patterns in Ruby". Having at one time counted myself as a true-believer in everything pattern-esque, I was excited for the opportunity to learn Ruby under the aegis of The Gang of Four. However, what I found was something else entirely. I absolutely loved "Design Patterns in Ruby" for reasons that I was not expecting. That is, what I found was an extremely interesting book that was playful and as a nice side-effect *actually taught me how Ruby's powerful features make many design patterns unnecessary*.

Olsen, with his latest effort has mastered the art of writing a book that is extremely interesting, fun, and informative. As an author myself, I greatly admire the ability in other authors to take what many would consider dry and bland, a programming language book, and create something that is truly special. Let me not give the impression that "Eloquent Ruby" is filled with fluff however; on the contrary, of any Ruby book that I've read I have learn the most from Mr. Olsen's masterpiece.

"Eloquent Ruby" is written for the programmer like me: someone with previous programming experience, but with only a passing understanding of Ruby itself. The structure of the book will help guide the Ruby neophyte toward a stronger understanding of not only the language constructs and idioms, but also the Ruby culture. As an outsider to said culture, I've always viewed the Ruby community as merely a collection of characters, but Olsen's book helps to illustrate that (almost universally) Ruby practitioners first and foremost strive to create correct and robust solutions. As a proponent of the Lisp family of languages, I tend to look askance at languages falling into the ALGOL family, but "Eloquent Ruby" has succeeded in convincing me that with the right approach and mindset then Ruby can be a stunningly beautiful language. And this is really the key point to take away from Mr. Olsen's book. That is, he guides the reader through the Ruby mindset to drive home the point that Ruby's features -- from its powerful and fluent blocks and modules, to the mind-bending metaprogramming facilities, to its to its humble symbol, and through its philosophy of "Objects all the way down" -- play together in such a way as to foster ... well, elegance.

The highlight of the book is of course its dénouement that succeeds in pulling together all of the lessons presented throughout the book into explaining the role that Domain-Specific Languages (DSL) serve in solving programming problems with Ruby. I can't possibly do justice in summarizing this important technique, but the punch-line is that Ruby's features foster the creation of powerful and expressive DSLs used to simplify the development of complex solutions by allowing the language itself to be molded into a form that is highly expressive to said solution! It takes a while to see the power in this technique, but "Eloquent Ruby" makes a compelling case indeed.

Russ Olsen has helped me to gain more experience points in Ruby, and I must say that I am excited to learn more. If you too wish to learn more about Ruby, then you would be hard-pressed to find a better book than "Eloquent Ruby" in helping you to do so.
0Comment| 47 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 5, 2011
I can't even begin to imagine how difficult it would be to write a book covering such an in-depth topic as the Ruby Programming language. Add to that a target audience with a widely diverse range of skills and the tasks seems to be out right impossible. Fortunately for us mere mortals Russ Olsen has taken on this challenge and surpassed my high expectations in his second book, Eloquent Ruby.

The first part of the book is for the Ruby newbies, but takes an interesting deviation from most programming books. Instead of focusing simply on the syntax and language libraries, Eloquent Ruby focuses on the community aspect of the Ruby programming language. Each programming community has its own style and norms and without a lot of direction and practice, these style and norms can be difficult to learn. The Ruby community is heavily opinionated and Russ's book does a great job of explaining these opinions and their manifestation in many Ruby codebases.

In Part Two of Eloquent Ruby, Olsen dives into the core concepts and building blocks of the Ruby programming language. This section of the book covers the everyday usage patterns and common best practices when working with Ruby's classes, iterators, blocks, and modules.

The power and flexibility of Ruby is put on full display in Part Three of Russ's book. Newcomers to Ruby are often mystified by Ruby code that appears to be doing magical things like dynamically adding methods to a class. In this section, Russ pulls back the curtain and explains the magic that is metaprogramming. Those unfamiliar with the concept may find the topic confusing at first, but Olsen breaks it down in a way that is easy to understand. This section thoroughly covers Ruby's method_missing hook and how to open classes to add your own customizations.

In the last section Russ ties a lot of the concepts of the book together through a discussion on how Ruby can be used to create Domain Specific Languages (DSLs). As a bonus Russ finishes the book with a chapter on how to package your code into a gem (Ruby library) and a chapter on the different Ruby Implementations.

At almost 400 pages I feared Eloquent Ruby would take a while to read, but I was pleasantly surprised at the pace at which I made it through the book. Even though the book was a quick read it still felt as if I had gained a lot of new knowledge after its completion. I credit the speed reading and depth of understanding to Olsen's writing style. The book is broken up into 30 concise chapters that each focus on a specific topic. This makes the book's information very easy to digest.

Following a similar pattern from his first book, Design Patterns in Ruby, each chapter of Eloquent Ruby describes code examples "In the Wild" where Olsen discusses code snippets from open source projects using the topics covered within that chapter. In my opinion giving "real world" code examples was a great way to prove the relevance of the information covered in the book. Overall, Eloquent Ruby was a great read and I'd highly recommend it to Rubyist at all skill levels.
0Comment| 28 people found this helpful. Was this review helpful to you?YesNoReport abuse
on April 30, 2014
The book is very interesting but all code examples are as images rather than text and with extreamly small font. It's almost imposible to read it. It can be zoom in but than looks awfuland it's annoying to do that every second page.
22 comments| 16 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 28, 2013
i'm a web and middle-tier developer with a strong background in c# and java and have been teaching myself ruby for about a year now (in the hopes of soon building rails apps.) I started w/ (extremely utilitarian, but extremely dry) "the ruby programming laguage" (flanagan, matsumoto) and that was a good way to get familiar with syntax and basic structure (and is a great tool to have on the shelf), but i often found myself scratching my head while sifting through code on github (which is a quick way to get really really confused if you're new to ruby) ...

this book elucidates A LOT of the basic ruby-isms that i've encountered in the wild and really helped me build some foundation. a basic, but useful, intro to blocks, metaprogramming, and many other ruby-isms. a must-have for those learning, and/or looking to solidify their ruby.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on April 23, 2011
I bought Russ Olsen's "Eloquent Ruby" (the ebook version) sight-unseen, based solely on a Twitter recommendation by Ruby author/maven Peter Cooper. I'm glad I did. "Eloquent Ruby" is the textual equivalent of comfort food to me; the basic flavor is quite familiar, but with this book I've found my favorite recipe. Also, it has occasional nuggets of unexpected awesome baked in that make me want to come back for seconds and beyond. Part cookbook, part HOWTO (and, importantly, HOWNOTTO), and part pattern book (in a good way), "Eloquent Ruby"'s style is *not* any of the preceding. In fact, it is like no other book on the Ruby language that I've read, and I've read lots. In many ways it's a worthy complement to "The Pickaxe" book (Dave Thomas's "Programming Ruby", from the Pragmatic Programmers). Where the Pickaxe tells you exhaustively what Ruby *can* do, "Eloquent Ruby" tells you what you *should* use Ruby to do, and how you should do it. If you like the O'Reilly "[technology-name-here]: The Good Parts" book series, I'm betting you'll like this book, whatever your level experience as a Ruby programmer. Don't miss any of the footnotes, which are by themselves entertaining enough to justify purchasing the book. And if you find another tech book that appropriately and un-forcedly uses (and correctly spells) the word "legerdemain", please let me know what it is. 'Cause I want to read that one too.
0Comment| 7 people found this helpful. Was this review helpful to you?YesNoReport abuse
on May 27, 2013
After you have gotten down the basics of Ruby syntax this is the next step. Much of the ruby community I've found likes to talk about the esthetics of the code. They not only want to write good working code but want it to be beautiful. When I first got into Ruby I asked a senior programmer about style and his answer was to read the ruby discussion lists and I would eventually pick it up. I did not, this may be a reflection on me but after six months of trying to wrap my head around Ruby I was still just not getting what I considered weird rubyisms. Much of this book is about explaining style and why your actually writing better code when you do things the ruby way. It's about using the somewhat unusual features of the language to build better working code. It also spends a fair amount of text explaining the dangers of each feature and how best to mitigate danger while still keeping the power.
0Comment| 4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 28, 2012
A pleasant journey through how Ruby makes expressing certain solutions more pleasant. It gradually builds in complexity from basic syntax through metaprogramming to creating DSLs and looking at the source code of Ruby implementations. It is not intended to be your introduction to Ruby, but the dedicated learner could probably use it in that way. For everyone else, I'd suggest starting with Programming Ruby 1.9: The Pragmatic Programmers' Guide (Facets of Ruby) or The Well-Grounded Rubyist.

I've been using Ruby for a while, so I already knew some of the material covered. My style has always been fairly restrictive, though - closer to C++ than Ruby. Olsen gave me a solid respect for metaprogramming - how it works and when you should do it. Also, I love that he used real world examples of projects "in the wild" which use the techniques he demonstrated. If you read the book, follow along and look at those projects. It makes the material much clearer.
0Comment| 8 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 26, 2014
It does a decent job. But it's still too long, and the explanations aren't as practical, but tend to go quite into the deep theoretical rabbit hole that veers away from real code usage (ignores how useful and frequent certain concepts are, but goes into them anyway, without regard to how frequent or how useful they may be.) It's not bad, but I wouldn't be trying to learn ruby right off the bat with a book that doesn't do an excellent job with concise explanations, and saves me time. I'd go to the many online resources that covers the main, more used aspects of ruby much more quickly and interactively instead.

Becoming an expert is an iterative process, not reading a book, and then suddenly knowing everything.

Still, is is thorough, and it does provide sufficient examples. I'd leave this book for after you got your hands dirty with ruby via online courses, and maybe then, not even so. You can jump into rails to actually create things with a bit of ruby knowledge to start, and learn ruby better while using it, (like that parentheses are optional for comma-separated arguments, that if a hash is the last argument, then you also don't need to use parentheses, blocks, procs, lambas, etc.

This ruby book is for people who've familiarized with ruby, built apps by following tutorials with rails, gotten hired as a junior developer, and is now needing to know ruby much better to work with production-level apps that seasoned developers utilize.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on August 25, 2011
Russ Olsen has turned in an excellent Ruby style guide with "Eloquent Ruby". It presents itself as an onbooarding reference for Ruby newcomers, but I think it's just as useful for Ruby veterans.

This isn't a reference book like "The Ruby Way" or the Pickaxe book. Instead, it introduces the reader to the idiomatic Ruby way to do something they might do in a less flexible or appealing way coming from another language. Along the way, you'll learn about choosing the right control and data structures for the job, employing language features like blocks, Procs and lambdas to decouple your code, extracting shareable code into Modules, writing DSLs and more.

My bookshelf is stuffed with programming books, and I have some excellent Ruby ones. Whenever anyone asks for a recommendation, my top three are "The Well-Grounded Rubyist" (Manning Press), "Metaprogramming Ruby" (Pragmatic) and now "Eloquent Ruby". It deserves a spot on your bookshelf.

Highly recommended.
0Comment| 5 people found this helpful. Was this review helpful to you?YesNoReport abuse