Ruby by Example: Concepts and Code (Paperback)

by Kevin Baird (Author)
Key Phrases: irb session, true irb, user system total, Hacking the Script, Album Controller, Canadian Dollars (more...)

Editorial Reviews

Product Description
There may be no better way to learn how to program than by dissecting real, representative examples written in your language of choice. Ruby by Example analyzes a series of Ruby scripts, examining how the code works, explaining the concepts it illustrates, and showing how to modify it to suit your needs. Baird's examples demonstrate key features of the language (such as inheritance, encapsulation, higher-order functions, and recursion), while simultaneously solving difficult problems (such as validating XML, creating a bilingual program, and creating command-line interfaces). Each chapter builds upon the previous, and each key concept is highlighted in the margin to make it easier for you to navigate the book.

You'll learn how to:

• Use the interactive Ruby shell (irb) to learn key features of the language
• Extend Ruby using RubyGems, the Ruby package manager
• Create numerical utilities, as well as utilities that process and analyze HTML/XML
• Implement purely functional and metaprogramming techniques to save time and effort
• Optimize, profile, and test your code to make sure that it not only does its job, but does it well
• Create web applications using Rails

Ruby is the fastest growing programming language today, and for good reason: Its elegant syntax and readable code make for prolific and happy programmers. But it can be difficult to understand and implement without a little help. Ruby by Example shows you how to take advantage of Ruby as you explore Ruby's fundamental concepts in action.

About the Author
Kevin C. Baird received his Ph.D. from the State University of New York at Buffalo. He originally wrote his dissertation in Python but rewrote the project after discovering Ruby, and he hasn't looked back since. He has presented at RubyConf and written articles for Linux Journal, Music & Computers magazine, and the New Interfaces for Musical Expression conference proceedings.

Product Details

• Paperback: 326 pages
• Publisher: No Starch Press (June 8, 2007)
• Language: English
• ISBN-10: 1593271484
• ISBN-13: 978-1593271480
• Product Dimensions: 9.1 x 7 x 1.1 inches
• Shipping Weight: 1.3 pounds (View shipping rates and policies)
• Average Customer Review: 4.4 out of 5 stars See all reviews (12 customer reviews)
• Amazon.com Sales Rank: #242,152 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

9 of 9 people found the following review helpful:

5.0 out of 5 stars Ruby Language Immersion by Examples, August 26, 2007

By	Scott Schram (Birmingham, AL USA) - See all my reviews (REAL NAME)

"Ruby by Example, Concepts and Code" teaches the Ruby language through immersion in examples.

The book begins with a brief introduction to Ruby and the interactive Ruby shell (which allows typing in Ruby code and immediately seeing the results).

The 45 examples that follow are carefully crafted to introduce new language features. A typical example includes these sections:

* The Code
* How It Works
* Running the Script
* The Results
* Hacking the Script

The reader is tempted to open up the examples in an editor, run them and tinker with them.

There is a focus on programming paradigms (or styles). The three main types covered are: imperative, object-oriented and functional. The imperative style "tells computers: Do this, then do that, then do this next thing." "Object-oriented languages define objects (types of things) that know how to perform methods." "Functional languages treat programming problems like mathematical relationships" and allow handling of functions and blocks of codes as if they were objects themselves. Ruby has strengths in all three of these areas, but this book offers more coverage of the functional paradigm than you might see elsewhere.

The examples advance in scope and complexity and cover practical topics like HTML and XML handling, CGI programming (which is a simple technique to make programmable web pages) and finally a sample Ruby on Rails web application.

An appendix compares and contrasts Ruby to several other languages (C, Haskell, Java, Lisp, Perl, PHP, Python and Smalltalk). For each language, the author gives some history, the particular focus or strengths of that language, and how Ruby was inspired by or shares some of the best features of each.

Baird sees Ruby's greatest strengths as "readability, a high level of abstraction (and great ease in extending that abstraction even higher), internal consistency and conceptual elegance."

The book is designed to be accessible to a beginning programmer, but would be challenging (in a good way).

Programmers with experience in another language or with some Ruby experience would strongly benefit from reading "Ruby by Example", even if they have read another tutorial book or started working with Rails applications.

6 of 6 people found the following review helpful:

3.0 out of 5 stars Tries something a bit different, is mostly successful, January 26, 2008

By	Thing with a hook - See all my reviews

Ruby By Example seeks to teach Ruby by introducing a series of small scripts, explaining how they work, often by showing some examples in irb, Ruby's interactive shell, and reinforcing the explanations with some suggested modifications to the script to highlight the principles just expounded. The closest examples in other languages I'm aware of are Dive Into Python and (to a lesser extent) Wicked Cool Perl Scripts.

This is a very nice idea, and there are some examples that are a cut above the usual fare: chapter 9 includes a Bible Code generator, and an implementation of the 'methinks it is like a weasel' sentence natural selection program from Richard Dawkins' The Blind Watchmaker. There's also mention of memoization, profiling and benchmarking, the Schwartzian transform for sorting, and even Symbol#to_proc. There's also quite a gentle introduction to Rails, which is probably sufficient for someone new to Ruby and Rails to move onto Ruby for Rails.

However, the execution isn't always perfect. Probably the biggest downside to this pedagogical approach is that there's not really one obvious place to describe how a particular feature works in depth, or the focus moves away from its practical use in a script. As a result, many of the explanations are compressed. Chapter 1 provides a 'crash' description of object orientation in 9 lines. Chapter 3 first mentions hashes, but compares them to functions, and not to arrays. Tail recursion is defined in a 4 line footnote in chapter 7. If you already understand these concepts, you'll be fine, but they won't teach you anything. If you don't, they aren't very helpful. At a couple of points the book also insists that everything in Ruby is an object, but code blocks (among other things) aren't until they're wrapped in Procs. For the more functional-esque techniques advocated in the book, this is a subtle point which could trip up a beginner.

Also, some of the examples are weak. Chapter 4 rushes through regular expressions, using them to compress whitespace, but why not also mention String#squeeze? Chapter 5 uses regexes to deal with XML and it gets the job done, but advice on using a real XML parser might have been more useful in the long term. Chapter 6 contains a truly contrived Buffy the Vampire Slayer-related example.

This isn't a bad introduction to Ruby, and it's a very admirable attempt to do something different, but I wanted to like it more than I did. If you already know some object oriented programming, this could make a good companion to a more tutorial-style book, like The Pickaxe.

8 of 9 people found the following review helpful:

5.0 out of 5 stars The Perfect Way to Learn Ruby..., July 19, 2007

By	Michael Ivancic (Buffalo, NY - USA) - See all my reviews (REAL NAME)

This book has really helped me dive-in, start using, and more importantly start understanding Ruby. About a year before this book came out I read the Ruby Pick Axe but didn't feel like I had a great understanding and command of the language (I was also new to object oriented languages). I needed real life examples and actual code that illustrated Ruby concepts and showed them in action. That's exactly what I got with this book.

I think this book would be an excellent choice for someone wanting to learn Ruby, regardless of your level of programming experience. I'm self-taught with entry level programming skills and I had no problem understanding the concepts and examples in this book. The book even explains the basics like variables, objects, and methods and doesn't assume you know anything about object oriented languages, programming, or Ruby. The example scripts are pretty neat and very useful too. I've already started customizing my own version of the sample Rails photo album for my wedding pictures too. (Thanks Kevin!)

Whether you're looking to learn how to program or looking to learn a new language, I would highly recommend this book! I plan on keeping it in my programming book collection!