The Book of Ruby: A Hands-On Guide for the Adventurous

Good book for getting the basics of ruby.Project based learning

very informative, however a bit outdated as it only covers ruby 1.8 & 1.9

Too many simple things missing, just look through the index. Nice try but it could have used input from a few reviewers before hitting the presses.

Fast and good

more than meet my expectations

I've been reading this book trying to find what's good about it, and the best thing I might say is that, after reading it, you will probably be able to write a Ruby program that runs. But, given all the other "intro to Ruby" books out there, I can find no good reason for this book to exist.It fails in a number of ways. First, right off, the author says that Ruby allows much latitude in code style. You can, if you like, use method names such as myCamelCase method or myhardtoreadmethod or my_snake_case_method. This is true. But the author fails to explain that while the Ruby interpreter may not care, the vast majority of experienced Ruby developers most certainly will, and learning to follow some basic community coding conventions will go a long way in helping you work with other Rubyists, even just get some coding help as you learn.Second, even if we ignore that, the author for whatever reasons seems to make a point of avoiding *any* coding style. Class and method name follow no apparent reasoning; parenthesis are included or omitted at random (even after the author says he prefers them for clarity). Following this book your Ruby code will look, at best, ugly, and almost certainly amateurish.There are also assorted annoying technical inaccuracies and omissions. For example, the book says that attribute getters and setters are like properties in other languages. Well, no; languages that make a point of having properties (e.g. Java) do not allow you to override them; unlike in Ruby, properties are not methods. It's an example of an important aspect of Ruby that should be grasped early on, not glossed over.What's especially frustrating here is that this is the sort of topic that makes for perfect introduction to Ruby's object model and brand of OO. It uses a message-passing paradigm, and even things that may *seem* like properties are *not*; they are methods invoked by sending the appropriate message.Least you think this a trivial detail my experience has been that people learning Ruby get tripped up later on because they did not start out with a clear and correct mental model of how Ruby executes code. Hence, thinking of attribute accessors as anything other than just methods that happen to have matching names creates (for many, at least) a false mental model.To be fair I don't think I came across anything that made me think, "That's completely wrong", but there were a few too many cases of, "Well, that's not *quite* right", or, "Technically true but missing an important point." It made me feel that the author really didn't know the language (an odd thought given that he's written an IDE in Ruby, but there you go).I've spent enough time using Ruby to come to appreciate the value of understand key language concepts right from the start. I've learned the hard way and had to unlearn a few things in order to become a better Rubyist, so I've low tolerance for any introduction that takes the easy road in presenting the language.The book goes on with explanations and examples of assorted Ruby syntax, but offers no insight about Ruby itself. You will not get a proper understanding, for example, of how singletons, modules, and classes operate when a message is handled. You will not get any idea of what experienced developers call "The Ruby Way". You might learn operational syntax, but for that you may as well use one of the many free Web resources.This books makes no useful contribution to the body of Ruby knowledge, and may do more harm than good. Stay away.

Disclaimer: No Starch Press provided me a free copy for review.First, I am a big fan of NoStarch titles. I like the way that they are organized and the way that the information is presented. In this classification, The Book of Ruby by Huw Collingbourne fits well into the publishing method NoStarch is famous for. It's a beautifully designed book, and the formatting and the prose itself is easy to follow. It's a good overall reference, and the format is helpful to find areas that are of interest quickly (this is a hallmark of pretty much all of NoStarch's books). In fact, I'd say the strongest element of the book is the NoStarch format and the ability to quickly find what interests you.The books starts out well, with clear syntax and presentation of topics, you feel like you are on top of things. The problem comes with trying to work through the book as you go through the examples. There feels like a disconnect between chapters, and I personally felt it a little slow going, requiring resetting and rereading the chapters. I found that using it as a reference book on the given topics is the most effective, but it doesn't work as well as a continued narrative. To be fair I'm reviewing this from a perspective of being an "advanced beginner". This means I've read a few books on Ruby and have written a few programs, but don't use it enough yet to consider myself to be proficient, or for that matter even an intermediate user (though I use Cucumber fairly extensively and patch it with Ruby as needed). I think it's important to state where I am at so I can state why I'm scratching my head at some points.While I think Huw's explanations work for most of the examples, there's just this nagging feeling that I'm missing something as I read through and work on them. I did like the "Digging Deeper" sections. These allow the author to go more in depth on a specific topic. I actually wish there were a few more of these in the book, but I appreciated the ones that were included.Another area that I found disconcerting was that there was little emphasis on a consistent coding style. Yes, most languages allow for different stylistic approaches and indenting/not indenting isn't a huge deal, but it can be frustrating when comparing books from different sources. A consistent style would have helped me see patterns and perhaps not need to back-track and reread certain sections.I think there are many good aspects of the book, and I think that there are many benefits. However, if a user were to pick up a single title to get started with Ruby, I'd probably steer them to "Learn to Program" from Chris Pine or "Learn Ruby the Hard Way". After reading those, I think The Book of Ruby would stand better as a supplementary text.

Ce livre s'adresse à des développeurs ayant déjà une certaine connaissance du langage,je recommande à ce propos le livre "The Well Grounding Rubyist" (en anglais) pour une initiation très profonde.

Great book!