Albuquerque Ruby Group

Book reviews (ratings are from 1 to 5 stars)

Inside the Machine

by Jon Stokes
O'Reilly, ISBN-13 978-1-59327-104-6



Jon Stokes takes us on a journey through time, beginning with a trivial hypothetical processor, marching through the fundamental design decisions and trade-offs that microprocessor designers have made over the years with subsequent versions of their products.

Each major component of microprocessor architecture is described. Rarely does a book so perfectly describe a complex subject in simple and easy to understand terms. The book is full of excellent color illustrations that help drive the subject matter home.

In the introduction, Jon describes the book as an "introduction to computers that is intended to fill the gap that exists between classic but more challenging introductions to computer architecture...and the growing mass of works that are simply too basic for motivated non-specialist readers." That statement is spot on.

Topics covered include 'basic computing concepts', 'mechanics of program execution', 'pipelined execution', 'superscalar execution', '64-bit computing and X86-64' and 'caching and performance'. Processors covered include Intel (Pentium, Pentium Pro, Pentium 4, Pentium M, Core Duo, and Core 2 Duo) and Motorola (PowerPC 601, 603, 604, 604e, 750 aka G3, 7400 aka G4, G4E and 970 aka G5).

This book provides excellent, in-depth coverage of real-world microprocessor design. It earns top marks from me for its easy accessibility and high quality writing.

by Dave Walz-Burkett

High Performance MySQL

by Jeremy Zawodny & Derek Balling
O'Reilly, ISBN-13 9780596003067



High Performance MySQL opens with a quick chapter describing various MySQL installation options including binary packages and compiling from source code. The next chapter describes the different storage engines available in MySQL and why you would want to choose one over another. This is the book's first hint of what you can do to improve database performance: picking the right table type.

Skilled software developers use benchmarking to gain insight into how their software is performing and database benchmarking should be part of that strategy. A brief chapter introduces some database benchmarking strategies and tools.

Chapters on indexing and query performance follow, describing some of the most important skills to master. Following that, replication and load balancing are discussed. Backup and recovery options are covered, as is the topic of security.

A somewhat thin trio of goodies rounds off the book in the appendices: the SHOW STATUS / SHOW INNODB STATUS commands, the mytop tool, and the phpMyAdmin user interface.

Overall, I found many possible areas for performance improvement that I had not thought of before. At 278 pages, a lot of material is crammed into this book. It's a quick read and if you're a MySQL admin or a developer using MySQL, you're bound to find something useful here!

by Dave Walz-Burkett

SOA in Practice

by Nicolai M. Josuttis
O'Reilly, ISBN 0-596-52955-4



Service-oriented architecture is more than just another IT buzzword. Most companies, large and small have heard of SOA and have either jumped on the bandwagon or have plans to do so in the near future.

SOA in Practice covers a lot of ground and provides definitions and descriptions of the complex world of SOA. Initially, the book describes the motivation to adapt a service-oriented architecture. It then proceeds into a discussion of the elements of SOA and reiterates that SOA is no silver bullet.

The author makes it clear that SOA is an ideal solution for a specific set of circumstances: "heterogeneous distributed systems with different owners." If that simple definition doesn't fit your organization, SOA may not be for you.

If you are still committed to learning about or implementing SOA after understanding what it is and what it can (and can't) do for your organization, read on! The remainder of the book present an in-depth look at all elements of service-oriented architecture.

I particularly enjoyed the chapters covering the enterprise service bus and message exchange patterns. In a nutshell, they show some of the many possibilities of how SOA can be implemented - indicating that there is no 'one right way' to do it.

Web Services (not a requirement of SOA) is discussed, as well as the management of services, model-driven service development, and advice on establishing SOA in your enterprise.

The book is light on technical details. This is obviously intentional as its core focus is not the nitty-gritty of how to make it work. It is more of a high-level, conceptual view of what SOA is all about and how it can help your enterprise solve difficult challenges when faced with integration of heterogeneous systems.

by Dave Walz-Burkett

MySQL Stored Procedure Programming

by Guy Harrison with Steven Feuerstein
O'Reilly, ISBN 0-596-10089-2



I have been working with MySQL for several years as a database back-end for Java, Ruby and C# programming projects. After upgrading to version 5, I have been meaning to look into MySQL's support for stored procedures.

The MySQL Stored Procedure Programming book was my first read on the subject and I found it quite useful. It covers not only stored procedures, but also functions and triggers, collectively called 'stored programs' in the book. While there are many books on MySQL, this book is dedicated to the stored programs domain and provides a lengthy treatment of the subject.

During the introduction, the authors provide a veritable laundry list of MySQL resources including many books and websites. The basic tools for creating stored programs in MySQL are visited and help set the groundwork for a 'read, type in the example and run it' feedback loop. Throughout the book, the examples are clear and easy to follow.

The introduction is followed by a brief tutorial, highlighting stored procedures, functions and triggers. What follows is two sections of chapters, over 200 pages in length, diving into the details of the stored procedure language fundamentals, blocks, conditional statements, iterative programming, error handling, the creation and maintenance of stored programs, transaction management, MySQL built-in functions, stored functions and triggers.

The next section of the book is of particular value to software developers that use MySQL in their applications. Over 150 pages showing you how to use MySQL stored programs from PHP, Java, Perl, Python and .NET. The Java section even shows the basics of using stored procedures with Hibernate and Spring.

After that, you'll be greeted with a 110 page medley of options to help you optimize your MySQL stored programs. The subject of tuning your SQL is addressed over the course of three chapters, from basic through advanced tuning topics. Additional optimization techniques such as reducing network traffic with stored programs, optimizing loops, recursion, cursors, trigger overhead and more are found in the final chapter of this section.

The book closes out with a chapter on best practices in MySQL stored program development. MySQL Stored Procedure Programming has earned a space on the MySQL shelf of my technical library. It's a fine book that will help you take your MySQL programming experience to another level.

by Dave Walz-Burkett

Java Generics and Collections

by Maurice Naftalin & Philip Wadler
O'Reilly, ISBN 0-596-52775-6



Ever since the release of Java 5, I've been keeping my eyes open for a book that describes what I believe to be the most powerful new feature of Java - generics. The new book published by O'Reilly, Java Generics and Collections covers the topic in spades. As a bonus, the second half of this book examines the Java Collections Framework. Since the Collections Framework was rewritten to incorporate the use of generics, it makes perfect sense for the authors to spend a reasonable amount of time describing the new interfaces.

A brief introduction highlights the use of generics, autoboxing, foreach loops, generic methods and varargs. The examples are written using the Collections Framework. Subtyping and the use of wildcards follow the introduction and begin to show the real power of generics.

Getting past the basics, a chapter devoted to the Comparable and Comparator interfaces describes some very useful concepts, such as how to use the Comparable interface to find the minimum or maximum element in a collection. The use of enumerated types is briefly covered here, as well as the concepts of multiple bounds, bridges and covariant overriding.

A chapter describing how to declare a generic class helps you build your own classes. Following that is a useful chapter that describes how the design of generics is evolutionary, not revolutionary. It details how generics in Java 5 allow you to gradually migrate your legacy code, rather than replace it all at once.

If you use generic types in casts, instance testing, exceptions or arrays, a chapter on reification warns you of rough edges and limitations you may find and describes some workarounds. How generics changes reflection is also covered.

The last two chapters of the first half of the book describe how to use generics effectively in your code and provide samples of how implementations of select design patterns can take advantage of generics.

The second half of the book, which dives into the Collections Framework, starts with a quick chapter called 'Preliminaries' that spends time discussing underlying concepts, such as the Iterable interface. Thread safety issues are covered in this chapter as well. Thread-safe concurrent collections were introduced in Java 5 and their use, as compared with synchronized collections is also discussed.

The Collection interface is given its own chapter, which is important considering that it defines functionality common to any type of collection other than maps. Following are chapters describing sets, queues and lists. The Map interface also warrants its own chapter, in which the available methods and the various map implementations are discussed. The comparative performance of different set, queue, list and map implementations is shown in tables at the end of each chapter.

Following the Collection and Map interface chapters is the final chapter which describes the Collections class in detail. The Collections class contains static methods that operate on collections or return them.

I found the code and diagrams in this book very easy to understand and a great resource when trying to decide which collection or map implementation to use for a specific problem.

Once you learn how to take advantage of generics, you'll begin to write more useful, reusable code. This book now occupies a space on my shelf next to my Algorithms and Data Structures books.

Dave Walz-Burkett

Learning Ruby

by Michael Fitzgerald
O'Reilly, ISBN 9780596529864



If you are new to Ruby, there is an O'Reilly title you may want to check out: Learning Ruby by Michael Fitzgerald. This book is a short and concise introduction to the Ruby programming language that will help any Ruby newbie come up to speed quickly. At 238 pages, it is a light, easy read.

Experienced programmers will find a book that jumps right in and introduces language features one after another. The basics are covered in the first chapter, followed by a fairly comprehensive 'Quick Tour of Ruby' in the second chapter. After that, each chapter spends more time with a certain aspect of Ruby, like conditional operators, strings, math, arrays and hashes, files and classes.

The detailed chapters are followed by a chapter that covers some extras like processing XML, working with dates and times, reflection, metaprogramming, and exception handling among other topics. A final chapter takes a dip into the Ruby on Rails framework with a quick, 18 page tour.

The book finishes with a 'Ruby Reference' in Appendix A and the answers to the end-of-chapter questions in Appendix B. The Ruby Reference packs a lot of info into a handful of pages and is a great shortcut to the online documentation if the book happens to be next to your computer.

I enjoyed reading this book and the author's sometimes irreverent writing style.

Dave Walz-Burkett

Java Cookbook, Second Edition

by Ian F. Darwin
O'Reilly, ISBN 0-596-00701-9



I bought the first version of the Java Cookbook many years ago and it was a huge find back then. There were few online resources at the time loaded with really great, consistent sample code, like http://www.javaalmanac.com. The Java Cookbook filled a need then and it fills a need now.

The book covers subjects of interest for programmers with any level of Java expertise. It is written in the classic 'cookbook' format. Each chapter concentrates on a specific area, like 'Strings and Things', 'Pattern Matching with Regular Expressions', 'Object-Oriented Techniques', 'Network Clients', 'Database Access', 'Threaded Java', etc.

Within each chapter, several problems are tackled. One or more pages are devoted to each problem, with a general format of: 'Problem', 'Solution', and 'Discussion'. Many of the problems build on previous solutions. Nearly every solution contains a Java example and the code tends to be simple enough to grok at a glance.

The book has been updated to cover most of the new Java 1.4 and 1.5 goodies, but doesn't have as much coverage as I would have liked. However, the most fundamental topics are covered well. The 800+ page book includes 312 recipes that cover a wide range of topics.

If you are like me and spend a lot of time learning by example, you will find this book an excellent resource.

Dave Walz-Burkett

MySQL Cookbook, 2nd Edition

by Paul Dubois
O'Reilly, ISBN 0-596-52708-X



The MySQL Cookbook weighs in at over 940 pages and will help you find quick answers to everything from beginner-level basics up through dba and software developer tricks.

The book is a collection of real-world tasks and compliments Paul's DuBois' other MySQL books very well. It goes beyond basic use and admin-level goodies - it has loads of code examples as well. As a software developer using MySQL for many projects, I find the MySQL Cookbook indispensible.

Dave Walz-Burkett

TextMate - Power Editing for the Mac

by James Edward Gray II
The Pragmatic Programmers, ISBN 0-9787392-3-X



This book is the perfect primer for what I have found to be one of the most indispensible Mac OS X applications - TextMate. If you are a software developer or web designer or anyone else that edits text on a frequent basis and you have not already discovered TextMate, stop right now and visit http://www.macromates.com.

The Pragmatic Programmers' book, TextMate Power Editing for the Mac is a thorough introduction to TextMate. Edward Gray II has written a very accessible book, that covers the product very well.

The first third of the book is devoted to the basics - things you do every day in your text editor. The second third of the book dives into the details of some really sweet features of TextMate that you'll find yourself using all the time: bundles, snippets, macros and UNIX shell commands.

TextMate ships with over thirty 'bundles'. Each bundle is a directory of related files that provide additional functionality to TextMate. Let's say you're working on an HTML file. The HTML bundle will help you with loads of things related to your document: validate the syntax of the document, open the document in the default browser, refresh the document in the current browser session, insert open/close tags for the current word, strip all HTML tags from the document - just to name a few. Each bundle provides functionality that applies not only to the syntax of the language you're currently working with, but repetitive tasks that would apply as well.

As I mentioned, a couple dozen bundles ship with TextMate and many more are available for free download from various websites. You can even create your own bundles to extend the product in ways that only you can imagine. Here are a few of the bundles that ship with TextMate: Blogging, CSS, HTML, Java, Markdown, Objective-C, Python, Rails, Ruby, SQL, Subversion, Text, Textile, Xcode and XML. Bundles provide you with lots of help editing files and performing related tasks.

Snippets are a smart completion mechanism that go way beyond the simple concept of 'finish this word'. For example, if you are editing a Ruby file and you type array_object.ea followed by the TAB key (where 'array_object' is an arbitrary Array object), the snippet feature will automatically fill in the skeleton of the 'each' iterator, including the opening and closing curly braces, the text '|e|' with the letter 'e' highlighted. You simply type the name of the variable you want to represent the next element (or simply leave it as it is), hit the TAB key again and the cursor will be placed between the closing '|' character and the closing '}' character, ready for you to type in an expression. Very cool. This same trick works for dozens of different scenarios in your Ruby code. And that's just the snippets that apply to Ruby code. There are snippets that apply to a large number of file types.

You've probably seen macros in other editors and TextMate's macro facility works as you might expect: you start recording a macro, perform some actions and save the macro. TextMate saves the macros as XML files, so it's a snap to edit a macro after recording if you need to tweak it a bit.

The ability to fire off UNIX shell commands from within TextMate gives you another powerful tool to use while editing files. You can fire off one-liner shell commands by simply pressing the ^R key on a line containing a shell command. You can also use shell commands to act on all or part of the current document.

For the advanced TextMate user, the tail end of the book shows you how to create your own language syntax for use in TextMate, including how to describe the grammar of the language in terms TextMate will understand. So, if you program in some far out funky language that TextMate doesn't support out of the box, you can add the language grammar to TextMate and program away!

Overall, I found this book extremely useful and easy to read. TextMate ships with an excellent help system that will answer many of your questions. The TextMate Power Editing for the Mac book will take you beyond the built-in help and give you an in-depth guide for this great Mac application.

Dave Walz-Burkett

Practices of an Agile Developer

by Venkat Subramaniam and Andy Hunt
The Pragmatic Programmers, ISBN 0-9745140-8-X



The authors open the first chapter with a Turkish proverb - "No matter how far down the wrong road you've gone, turn back." Good advice for life in general. Turns out it applies really well to dorked-up software development projects.

If you are new to agile software development practices, this book is a great, high-level introduction. Most of what software developers consider 'agile' practices are merely common sense - common sense acquired by programmers after much time spent doing things the hard way. Other programmers will keep doing things the hard way, because they simply have never seen, learned or figured out a better way to do it. Like most geeks, they occasionally need an introduction.

If you already use agile practices, you'll find this book a warm affirmation of what you're already doing. You might even find something in here that will help you squeeze out a bit more productivity on your projects.

The book addresses two of the more curious problems that keep teams from working with agile practices - where to start and how to keep it going once you do start.

The first chapter describes agile software development in general terms to help you get acquainted. Each additional chapter digs a little deeper by covering several practices related to the chapter title. Each practice is explained clearly in a few pages and is followed up with "What It Feels Like" and "Keeping Your Balance" sections that give a very succinct review of the practice.

The book is easy to read and short enough to keep as a desk reference for quick look-ups. A "Resources" section at the back of the book is a great jumping off point with links to excellent articles, tools and resources. The "Bibliography" section lists many useful books to help you explore the subject further.

But wait, there's more! A perforated, four-page cardboard foldout at the end of the book summarizes each of the forty-five practices.

A book like this in the hands of a ready-to-learn programmer might produce a wonderful growth spurt in the programmer's productivity and code quality. In the hands of a ready-to-listen software manager it might ultimately influence an entire team of developers in a positive direction. All in all, it's a well written book that I highly recommend.

by Dave Walz-Burkett

Ruby Cookbook

by Carlson & Richardson
O'Reilly, ISBN 0-596-52369-6



I've looked at a couple programming "cookbooks" over the few years I've been programming, and none have ever really captured my attention. Most of them I found were lacking in useful recipes for novice programmers, or the recipes used an outdated code style or covered specific areas of a programming language. And with others, I just found it difficult to find useful tips or tricks.

The Ruby Cookbook however, provides fresh, easy to read recipes that are full of neat tips and awesome tricks. And it's all provided in an easy to read, and more importantly easy to find, format. Programmers from novice to highly experienced will find this book useful.

The book is laid out using general data types as chapters at first, then moves into more abstract topics such as code blocks and modules; databases and persistence; web services and task automation with Rake.

Start with the table of contents to learn about a specific area, or thumb your way through the index to find specific topics or that fast piece of code you need to complete your project. No matter how you use it, the Ruby Cookbook is a must have book for any Ruby or Ruby on Rails programmer.

by Brian Anderson

iPod: The Missing Manual, Fifth Edition

by J.D. Biersdorfer
O'Reilly, ISBN 0-596-52978-3



By pure coincidence, I received the O'Reilly book titled 'iPod: The Missing Manual' on my birthday. It happened to be the same day I received a sleek new iPod Nano as a gift. After opening the iPod package, I immediately understood why the iPod book includes the phrase 'The Missing Manual'.

The iPod Nano ships with a brief 'iPod + iTunes Quick Start'. At sixteen pages, the accordion-fold Quick Start is the same size as the Nano, only a whole lot thinner. After you learn the most basic operations of your new iPod, the Quick Start ends and you're on your own.

That's where iPod: The Missing Manual takes over. The first forty-three pages cover operation of the iPod in great detail, describing each menu, including the one that helps you reset your iPod to English if you accidentally set it to display in Greek. The book covers all iPod models, including the standard video iPods, the Nano and the Shuffle.

The real meat of this book is its thorough coverage of the iTunes program. iTunes is where you spend a lot of time importing CDs, creating and organizing playlists, purchasing and downloading music from the Apple iTunes Store and synching your iPod with your iTunes library.

The final chapters of the book cover all sorts of goodies that you'll probably want to do with your iPod just as soon as you figure out you can. Playing slideshows of your pictures on a tv, using your iPod as an address book, a calendar and a portable hard drive are all covered in the book.

The book also describes some less well-known uses for an iPod, like reading text files and recording audio. It even mentions the funky Nike+iPod Sport Kit that tracks your progress when you workout by beaming a signal from your running shoe up to a small receiver that snaps into your iPod.

Easily the coolest thing about the book is that it's printed in full color with excellent photographs, screenshots and iPod menu graphics. The text is easy to follow and to the point.

Apple should bundle this book with every iPod they sell. If you have an iPod and want to learn how to use it for more than just the very basics, I highly recommend reading this book.

by Dave Walz-Burkett

Prefactoring

by Ken Pugh
O'Reilly, ISBN 0-596-00874-0



Prefactoring is an exposition of principles for software design, laid out in the context of the development of a fictional application. I've never been into that particular style of writing about software design; in fact, it was the only thing I didn't like about Martin Fowler's Refactoring, which is the inspiration for both Prefactoring's own fictional case study and its name as well.

When you've got one programming book named after another one, one reasonable idea is to compare the two. Prefactoring's premise is that, instead of fixing your design afterwards -- an extremely terse summary of Refactoring -- you apply what you've learned from that in the past to build it with the right design principles from the get-go. That sounds like good common sense, and it is. Unfortunately, it really only makes sense in the context of a misunderstanding of Refactoring. Refactoring and debugging are different things. It's very common in software for people to use buzzwords and catchphrases as an alternative to thinking, and consequently, in certain organizations, you'll hear "refactoring" used as a synonym for "debugging."

In fact, refactoring is supposed to happen during debugging -- but it's also supposed to happen during the course of development, and in fact this is the preferred time to do it. Refactoring comes from agile development, specifically Extreme Programming, where the basic cycle is to write unit tests, write the simplest code that can possibly satisfy those tests, refactor that code, and then begin again with new unit tests. Refactoring can mean improving things during debugging, but much more importantly, what it really means is streamlining existing code as you refine it. To say that the best thing to learn from refactoring is to get your code right first time is to use the vocabulary of agile development to advocate waterfall development, and this, in fact, is what Prefactoring often seems to do.

Worse still, many of the code examples are in Java, and they don't use Josh Bloch's guidelines from Effective Java or Java Puzzlers. This might be a quibble, but I'd certainly hire or fire based on this quibble, as I think it's very important (and therefore not a quibble at all). Pretty much everything I've done for months has been in Ruby on Rails, so I'm frequently reminded that Java is not popular in every sector of the tech industry -- however, if you are going to write Java, I personally feel that writing Java without observing Bloch's guidelines is careless at best, and borders on outright negligence.

On the other hand, I seem to be kind of eviscerating this book here, and that's not quite fair. I disagree with some of the design principles laid out in this book, but most of them are pretty strong in the common sense department. Also, software development is one of those things where you can be better off after reading a book even if you disagree with it. For instance, just in criticizing this book's attitude towards refactoring, I've had to question my own understanding of it. If you read this book with the right frame of mind, you'll challenge your own ideas and come to new conclusions, and probably become a better developer in the process.

by Giles Bowkett

The Book of Postfix

State-Of-The-Art Message Transport
by Ralf Hildebrandt and Patrick Koetter
No Starch Press, ISBN 1-59327-001-1



After having used Sendmail for over five years, I finally stumbled upon Postfix. I wish I had found Postfix much, much sooner. Don't get me wrong, Sendmail is a hugely flexible mail transfer agent (MTA) that currently handles the bulk of email on the Internet.

I decided to try Postfix after spending some time on the Postfix website (http://www.postfix.org), reading what appeared to be a fairly trivial configuration process for a simple, single domain setup. I wanted more information on serving up email for multiple domains and a deeper understanding of the nuts and bolts of Postfix.

That's when I found The Book of Postfix by Ralf Hildebrandt and Patrick Koetter, published by No Starch Press. The book will help you get a single domain email server up and running in the first three chapters. It includes an email primer for postmasters - a great tutorial if you haven't already covered the material.

Trying to light up an email server as powerful as Postfix (or Sendmail for that matter) requires patience and good documentation. You may already have the patience to pull it off and the Postfix website has excellent documentation. The Book of Postfix is like a mega-vitamin and sugar coating to top it off - it gives you the required dose of information to perform the task at hand and goes way beyond by giving you a wide array of extras that will increase your overall understanding of Postfix and email server technologies in general.

There is an excellent chapter that highlights the 'anatomy' of Postfix, describing what each tiny piece of Postfix does. The book covers message transfer restrictions and content filters in great detail.

After you have learned enough Postfix basics, the book dives into more advanced topics such as SMTP authentication and the Transport Security Layer. There is a sizable chapter on setting up a company mail server (based on Postfix, Cyrus SASL, Courier maildrop and Courier IMAP) that illustrates an excellent 'real-world' example of how you might use Postfix in a production environment.

The book finishes off with chapters on how to install, tune and troubleshoot your Postfix installation. I found this book very easy to read and understand and I think the material covered targets not only those new to email servers, but also seasoned postmaster veterans.

by Dave Walz-Burkett

Hackers & Painters

Big Ideas from the Computer Age
by Paul Graham
O'Reilly, ISBN 0-596-00662-4



If you've never heard of Paul Graham, this book provides an excellent introduction. Paul is a hacker (in the original sense of the word), a technology innovator and a philosopher for the computer age. This book of essays runs the gamut from 'why nerds are unpopular' to fixing the spam problem to what makes a 'dream language'.

As Paul says in the intro, each chapter is independent of the others and you can skip around as you like. You'll get the general feel for Paul's ideas in all of the essays and some overlap is evident. I read the book straight through and enjoyed every chapter.

Paul is a master of the Lisp language and describes how some modern languages are heading in the direction of Lisp. To solve really tough problems in a less powerful language, you tend to end up writing a Lisp interpreter in that language. He also describes why everyone isn't using Lisp for every program they write.

If you are a hacker or hacker wannabe, this book offers excellent insight into the mind of a master. If you are a 'pointy-haired' manager, you'll get a better understanding of how truly talented programmers think. If you are involved in a startup company, this book describes several topics that might help give you a competitive edge.

Most of all, this is a really fun book that will earn a permanent space on your bookshelf.

by Dave Walz-Burkett

Ruby Cookbook

by Carlson & Richardson
O'Reilly, ISBN 0-596-52369-6



Sometimes, the difference between getting a project off the ground and watching it linger on the launchpad is finding an example of how to do something in code.

Perhaps you're working on a project and you'd like to send an email using Ruby. Maybe you'd like to know how to read and write zip files or create thumbnail images from full size graphics files. Sometimes cruising through the API documentation just doesn't quite give you enough info.

The Ruby Cookbook fills the void for a portable version of a Ruby code snippet search engine. For each example, there is a Problem description, a Solution section containing one or more chunks of Ruby code and a Discussion section for follow-up. Most examples have a See Also section for cross reference.

A huge amount of material is covered. Topics range from simple stuff like strings, numbers, hashes, arrays and objects to more challenging subjects like code blocks, reflection, metaprogramming and multithreading. It has chapters on Internet services, Web services and distributed programming, and Web development with Ruby on Rails.

I'm only just skimming the surface here, this is a big book with 873 pages. It is quite simply packed with goodies. There is something in this book for Ruby programmers at every level. The book is well written and easy to read. You can download a zip file containing all of the code samples from the O'Reilly website.

If you want to learn Ruby and Ruby on Rails, there are three books that will help you more than anything else: Programming Ruby by Dave Thomas, Agile Web Development with Rails by Dave Thomas and David Heinemeier Hansson and the Ruby Cookbook by Lucas Carlson and Leonard Richardson.

by Dave Walz-Burkett