Learning Ruby (Paperback)

by Michael Fitzgerald (Author)
Key Phrases: ruby code, conditional love, elsif lang, More Fun, Review Questions, Installing Ruby (more...)

Editorial Reviews

Product Description
You don't have to know everything about a car to drive one, and you don't need to know everything about Ruby to start programming with it. Written for both experienced and new programmers alike, Learning Ruby is a just-get-in-and-drive book -- a hands-on tutorial that offers lots of Ruby programs and lets you know how and why they work, just enough to get you rolling down the road.

Interest in Ruby stems from the popularity of Rails, the web development framework that's attracting new devotees and refugees from Java and PHP. But there are plenty of other uses for this versatile language. The best way to learn is to just try the code! You'll find examples on nearly every page of this book that you can imitate and hack. Briefly, this book:

• Outlines many of the most important features of Ruby
• Demonstrates how to use conditionals, and how to manipulate strings in Ruby. Includes a section on regular expressions
• Describes how to use operators, basic math, functions from the Math module, rational numbers, etc.
• Talks you through Ruby arrays, and demonstrates hashes in detail
• Explains how to process files with Ruby
• Discusses Ruby classes and modules (mixins) in detail, including a brief introduction to object-oriented programming (OOP)
• Introduces processing XML, the Tk toolkit, RubyGems, reflection, RDoc, embedded Ruby, metaprogramming, exception handling, and other topics
• Acquaints you with some of the essentials of Rails, and includes a short Rails tutorial.

Each chapter concludes with a set of review questions, and appendices provide you with a glossary of terms related to Ruby programming, plus reference material from the book in one convenient location. If you want to take Ruby out for a drive, Learning Ruby holds the keys.

About the Author
Michael Fitzgerald describes Ruby as "my favorite language so far" and is working regularly with Ruby and the Rails framework. He has written over 150 Ruby programs for testing and demonstration, and has been developing a library of sample Ruby code. He is the author of Learning XSLT and XML Hacks, and co-author on the XML Pocket Reference.

Product Details

• Paperback: 275 pages
• Publisher: O'Reilly Media, Inc.; illustrated edition edition (May 14, 2007)
• Language: English
• ISBN-10: 0596529864
• ISBN-13: 978-0596529864
• Product Dimensions: 9 x 7 x 0.7 inches
• Shipping Weight: 12.8 ounces (View shipping rates and policies)
• Average Customer Review: 3.7 out of 5 stars See all reviews (18 customer reviews)
• Amazon.com Sales Rank: #274,739 in Books (See Bestsellers in Books)

• This item is part of The O'Reilly Learning Series.

Customer Reviews

Most Helpful Customer Reviews

21 of 23 people found the following review helpful:

2.0 out of 5 stars Learning Nothing, August 28, 2007

By	Michael Burton (Columbus, OH USA) - See all my reviews (REAL NAME)

When I read a computer book titled "Learning (Something)" and I don't learn anything, I have to ask myself: is the fault in the book, or in myself? This time, I believe, it's the book.

O'Reilly has an excellent reputation as a publisher of technical books. The table of contents suggests a carefully organized survey of language features, but the actual discussion is flighty and shallow. The author is clearly a Ruby enthusiast. It seems as if he wanted to mention everything, but didn't have time to EXPLAIN anything. In short order, he shows us eval, methods, blocks, and procs, but in the sample code, they all just print "Hello, Matz!" There is no discussion of when or why one technique might be preferable to another.

The book is full of sample code that illustrates syntax without even slightly illuminating the reasoning behind it. To illustrate logical AND:

if a == 10 && b == 27 && c == 43 && d == -14
print sum = a + b + c + d
end

Later the same tests are shown separated with "||" for logical OR. Beginning programmers might wonder, "Why in the world would I want to do THAT?" Better sample code would use scenarios where the specified actions make obvious logical sense. Experienced programmers won't have trouble with AND and OR, but the same unhelpful style of sample code illustrates unique Ruby features and more complex topics, too. (Maybe it's not a problem if you already know all this stuff.)

Each chapter ends with several review questions. Here are a couple from the first chapter: "What is the nickname of the inventor of Ruby?" and "Who wrote the pickaxe book?" To be fair, in later chapters some of the answers might be the name of an object method or a math constant. But all the questions test the reader's ability to repeat something from the chapter, never his real understanding.

Oh, maybe I'm too harsh, saying I didn't learn ANYTHING from this book. The nickname of the inventor of Ruby? Matz.

10 of 11 people found the following review helpful:

4.0 out of 5 stars A good book on the basics of Ruby, June 1, 2007

By	calvinnme "Texan refugee" (Fredericksburg, Va) - See all my reviews (TOP 10 REVIEWER)

This is a good book for someone who is planning to teach a beginners class in Ruby to others or has never seen Ruby before at all and wants to learn it themself from scratch. It does a good job on the basics, has plenty of examples, and even has review questions at the end of each chapter with answers at the back of the book. As far as learning anything past the basics of the language, including Rails and some of the more interesting things that can be done with Ruby, there are two short chapters that cover this information but do not go enough into the details. Once you read this book I suggest "Programming Ruby: The Pragmatic Programmers' Guide". That book goes into more detail as to what can be done with Ruby, but it also assumes you are not a beginner, which you won't be once you read this book. The table of contents is as follows:

1. Ruby Basics
Hello, Matz; Interactive Ruby; Resources; Installing Ruby; Permission Denied; Associating File Types on Windows; Review Questions;

2. A Quick Tour of Ruby
Ruby Is Object-Oriented; Ruby's Reserved Words; Comments; Variables; Strings; Numbers and Operators; Conditional

Statements; Arrays and Hashes; Methods; Blocks; Symbols; Exception Handling; Ruby Documentation; Review Questions;

3. Conditional Love
The if Statement; The case Statement; The while Loop; The loop Method; The for loop; Execution Before or After a Program; Review Questions;

4. Strings
Creating Strings; Concatenating Strings; Accessing Strings; Comparing Strings; Manipulating Strings; Case Conversion; Managing Whitespace, etc; Incrementing Strings; Converting Strings; Regular Expressions; 1.9 and Beyond ;Review Questions;

5. Math
Class Hierarchy and Included Modules; Converting Numbers; Basic Math Operations; Ranges; Inquiring About Numbers; More Math Methods; Math Functions; Rational Numbers; Prime Numbers; Review Questions;

6. Arrays
Creating Arrays; Accessing Elements; Concatenation; Set Operations; Unique Elements; Blow Your Stack; Comparing Arrays; Changing Elements; Deleting Elements; Arrays and Blocks; Sorting Things and About Face; Multidimensional Arrays; 1.9 and Beyond; Other Array Methods; Review Questions;

7. Hashes
Creating Hashes; Accessing Hashes; Iterating over Hashes; Changing Hashes; Converting Hashes to Other Classes; 1.9 and Beyond; Other Hash Methods; Review Questions;

8. Working with Files
Directories; Creating a New File; Opening an Existing File; Deleting and Renaming Files; File Inquiries; Changing File Modes and Owner; The IO Class; Review Questions;

9. Classes
Defining the Class; Instance Variables; Accessors; Class Variables; Class Methods; Inheritance; Modules; public, private, or protected ; Review Questions;

10. More Fun with Ruby
Formatting Output with sprintf; Processing XML; Date and Time; Reflection; Using Tk; Metaprogramming; RubyGems; Exception Handling; Creating Documentation with RDoc; Embedded Ruby; Review Questions;

11. A Short Guide to Ruby on Rails
Where Did Rails Come From?; Why Rails?; What Have Other Folks Done with Rails? Hosting Rails; Installing Rails; Learning Rails; A Brief Tutorial; Review Questions;

A. Ruby Reference
B. Answers to Review Questions

3 of 3 people found the following review helpful:

5.0 out of 5 stars Excellent Overview, May 16, 2008

By	R. Clay Stuart - See all my reviews (REAL NAME)

This is a great introduction to Ruby. It covers the basics without swamping the fledgling programmer in too much complexity. That's not what newcomers need. They aren't worried about the nooks and crannies of the array class; they're wondering what the heck an array is, and what makes it different from a hash. In that respect, this book strikes a nice balance.

Having read (and bought) most of the O'Reilly books on Ruby, Perl, and Python, I can honestly say that this book ranks high at the top of them--not because it is the definitive work on Ruby (it isn't and isn't supposed to be), but because it covers the core essentials in a way that you can read in an afternoon. For that reason, it is an excellent choice for a first timer in Ruby and/or programming to see why Ruby is a great language worth learning, without having to get a computer science degree first, and without having to hire a Sherpa to help them lug their book around while they read it (I'll refrain from pointing fingers at other books here).

I think that's one thing many of the reviewers missed about this book. "Learning Ruby" is designed for the newcomer who wants to get jump started in Ruby, not for the experienced programming who is just looking for a nutshell summary.

I would also like to add that at one point, I had a question about what was included with the one-click installation system and emailed the author, who very quickly investigated the problem and emailed me back with an answer. You have to admit: that's pretty impressive.

Now, there are areas of the book that should probably be expanded on for the next edition. Primarily, I'm thinking of a chapter devoted to regular expressions a la "Learning Perl", a chapter devoted to IO (this would be brief but handy) including a section on string interpolation and how to use and combine string methods (a very cool aspect of Ruby), and finally an expansion on the chapter involving classes to address a few of the things that some of the other reviewers have already identified as important but missing.

However, those are not fatal by any means, and for the first edition in a relatively new language, this book is well worth the time and money.