The book seems never to mention the RUBYLIB environment variable (except once in the 10.5 Security chapter, but it doesn't explain what it is, there or elsewhere). This is a crucial piece of information and should not be omitted. Modification of RUBYLIB is a very important technique.

In section 5.1.2, the third column of the three examples showing how to express an if structure:

(
line1
line2
) end if expression

...the word "end" is a mistake and should be deleted.

(Found in the 12/08 edition; haven't examined other editions.)
The line "@grid = @grid.dup" in the dup method defined in the Sudoku solver's Puzzle class doesn't assign to the new Puzzle object a new duplicate of the @grid array. Instead, the original Puzzle object is assigned a new duplicate @grid, and the original @grid has been moved to the new Puzzle object. Although this may not cause a problem in the context of the Suduko solver, the technique seems misleading and potentially risky.

Here's test code that demonstrates the problem:

class Puz
def initialize(grid)
@grid = grid
end
def dup
copy = super
@grid = @grid.dup
copy
end
def grid_objid
@grid.object_id
end
end
#----------------------
pz = Puz.new("xyzzy")
puts "pz grid object id is: #{pz.grid_objid}"
pz2 = pz.dup
puts "pz grid object id is now: #{pz.grid_objid}"
puts "pz2 grid object id is: #{pz2.grid_objid}"

The line:
x = "#This is a string" # And this is a comment

...should correctly read:
x = "#This is a string" # And this is not a comment

The line:
y = /#This is a regular expression/ # Here's another comment

...should correctly read:
y = /#This is a regular expression/ # And this is also not a comment

The following sentence...

After these lines have been read, the three string literals are concatenated into one.

...should also indicate that the the string concatenation is joined by newlines...

After these lines have been read, the three string literals are concatenated into one, joined by newlines (
).

The code example...

listing = Kernel.`(listcmd)

...is missing a closing `, but in either case (with or without a closing `) results in errors:

>> listcmd = 'ls'
=> "ls"
>> listing = Kernel.`(listcmd)
`# had to enter closing ` to proceed
SyntaxError: compile error
(irb):46: unterminated string meets end of file
from (irb):46
from :0
>> listing = Kernel.`(listcmd)`
SyntaxError: compile error
(irb):47: syntax error, unexpected tXSTRING_BEG, expecting $end
from (irb):47
from :0

s[s.length] = ?! succeeds in Ruby 1.9. The book states it is an error.

irb(main):001:0> s = 'hello'
=> "hello"
irb(main):002:0> s[s.length] = ?!
=> "!"
irb(main):003:0> s
=> "hello!"
irb(main):004:0>

$ ruby --version
ruby 1.9.1 (2008-12-16 revision 20770) [i686-linux]

Paragraph states "Note that these operators are not transitive: a|b is not the same as b|a, for example."

You're confusing "transitive" with "commutative." "Transitive" refers to relations like "<", and states, e.g. that (a < b && b < c) => (a < c).

from:
module Functional
.... omission....
# Example:
# product = lambda {|x,y| x*y}
# doubler = lambda >> 2 <== here

to:
module Functional
.... omission....
# Example:
# product = lambda {|x,y| x*y}
# doubler = product >> 2 <== here

double = lambda {|x| product(2,x) }

should be

double = lambda {|x| product[2,x] }

super doesn't just look at superclasses for chaining. It can also chain to methods inherited from modules. And a singleton method defined on an object can use super to chain to an instance method defined by the class of the object.

The sentence: "The eigenclass of an ordinary object stands alone and has no superclass" is not correct. The description of method lookup in this section is correct, but the details about superclasses of eigenclasses strays into messy implementation-dependent behavior.

See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/336490 for some discussion.

In the part about the method_added hook, it is said:

(...) there is no way to tell whether the named method was added to the class that defines method_added or whether it was added to a subclass of this class.

Next, a workaround solution for this problem is given. But in fact no workaround is needed - the class to which the new method was added is stored in self when inside the hook method. A simple code to demonstrate it:

class A;def A.method_added(m);p [self,m];end;end
class B<A;end
class A;def q;end;end # prints [A, :q]
class B;def w;end;end # prints [B, :w]

The nitems method of Array has been removed in Ruby 1.9.

Delete the following two lines:

[1,2,nil].nitems # => 2: number of non-nil elements