Well, as the headline of my review says; It's a MUST-HAVE for the serious Ruby coder.
Whatever the question, you'll find a very compentent answer and a very good explanation in this book.
The author knows his stuff hands down.
It's a pleasure to read the example code and see how elegantly written Ruby can be.
It's a book that should be used by anyone who has doubts about Ruby's power and elegance.

The first edition was already an amazing book, but the second edition really tops it.
Great work!

I wish other computer science book were this concise...

This is a book I could see being really helpful for someone who's done the Ruby tutorial and now needs to actually *use* the language to do something... The Ruby Way (2nd Edition) by Hal Fulton.

Contents: Ruby in Review; Working with Strings; Working with Regular Expressions; Internationalization in Ruby; Performing Numerical Calculations; Symbols and Ranges; Working with Times and Dates; Arrays, Hashes, and Other Enumerables; More Advanced Data Structures; I/O and Data Storage; OOP and Dynamic Features in Ruby; Graphical Interfaces for Ruby; Threads in Ruby; Scripting and System Administration; Ruby and Data Formats; Testing and Debugging; Packaging and Distributing Code; Network Programming; Ruby and Web Applications; Distributed Ruby; Ruby Development Tools; The Ruby Community; Index

Fulton states in the introduction that this book is not designed to be a "teach yourself Ruby" title. Instead, it's meant to explore the power and utility of the language by means of examples. Think of it as a *really* large cookbook-style volume. In each chapter, there are a series of how-to sections that are practical examinations of a particular technique. For instance, in the regular expressions chapter, you'll see sections such as using anchors, positive and negative lookahead, recursions in regular expressions, and detecting doubled words in text. This solutions-based approach to Ruby is perfect for someone who has covered the basics via a tutorial or some other book, but now has to actually use the language to do something. Personally, I find having a book like this is extremely valuable in making the jump from rank novice to functional developer. I know good code when I steal it... :)

I haven't done much with Ruby and decided it was time to dive in. I opened this enormous text and started. The book is broken down nicely into several beginners "howto" sections and then into more of reference and advanced learning portion.

Coming from a Perl programming background I found several things (mostly syntax) in Ruby quite odd and am very happy to have this reference on hand.

The GTK section of the book is very nice as I haven't seen it covered elsewhere. The additional coverage of Rails adds to the completeness of the material and helps the book win some popularity on a current hot topic.

This is a very well-rounded text for Ruby programmers. I would recommend it to anyone interested in learning Ruby, regardless of programming experience.

Yes, there are some typos in Fulton's book. But the vast bulk (and it is indeed a big text) can be profitably read. Either by someone wanting to learn Ruby from scratch or by a Ruby programmer searching for a solution to some common problem. For the former, the book may be too long. If you want to come up to speed on Ruby, ab initio, perhaps you might consider a slimmer text.

The book is best suited as a random access resource, for a Ruby programmer. As implied by the title. The 400 odd examples demonstrate a good diversity of usages of the language. Grouped according to broad topics like threads, user interfaces and networks. This helps you focus on finding a possible solution. However, suppose you can't find an exact match. The numerous examples may have one close enough to suggest an easy mod.

Granted, if a relevant example has typos, so that it won't run, that's a drag. But only a minor one. If you already know Ruby, fixing this should be a low level detail.

As far as comparing with other scripting languages, well the book does not do this. No mention at all of Perl or PHP. Probably the author regards this as outside the book's remit. The decision of whether you should use Ruby over those alternatives is something that cannot be answered by this book alone.

I'm reading the first chapter "Ruby in Review" and it is chock full of typos and mis-usages. This is particularly disconcerting pertaining to the very first sample program; e.g. it contains the statement "str.chomp!" but then the the ensuing explanation alternately refers to "chomp" as well as the previously un-discussed "chop". I'm an experienced Perl programmer and know the difference, but this must be confusing to other readers not lucky enough to have such background. Furthermore, referring to the same "chomp!" operation, the exclamation point is referred to as a prefix. This is incorrect: it's a suffix.

Computer language interpreters including Ruby itself would balk at such imprecision in code instuctions, and therefore I balk at such imprecision in English. It makes me wary that code samples later in the book will contain typos, though I give the book one star more than the minimum because the first sample program as entered in the book does run properly. Still though the editors should be ashamed.

I see this over and over with technical books: the first chapter(s) are flawed with such typos, probably because they get written and reviewed first, several months before the rest of the volume is finished. Further indication of this is the author's comment near the end of the first chapter that he is unaware of other languages with the "===" operator. Perhaps he wrote this for the first edition; by the time he wrote the second edition, particularly with the explosion of Ruby on Rails and Ajax, he should know that Javascript also provides the "===" operator (as does PHP).

In addition, the title of this volume is misleading and pretentious. Ruby suffers from the same "there's MORE than one WAY to do it" approach as Perl (e.g. "poetry mode" that dispenses with parentheses around method arguments). Perl has proven this sort of thing is a drawback, not a benefit. It's derisively referred to as a "write-only" language, and I predict Ruby will be considered likewise after 3-5 years when a sufficient base of Ruby code exists such that Ruby "maintenance" programmers will be in demand.

Furthermore, the author frequently notes how some of these multiple ways to accomplish things in Ruby can "confuse the parser"; there's no arguing this is a drawback. It can only further slow down a language already slow due to its interpreted, dynamically-typed, object-oriented nature.

Tech authors, do yourself a favor, and have somebody (re)edit your initial introductory chapter(s) at the tail end of the process, otherwise risk making a bad first impression. Programmers, do yourself a favor, and don't just blindly jump on the Ruby bandwagon.