Historical errata for Programming Ruby 1.9

“Although threads can no take advantage” => “Although
threads can now take advantage”

“but only every operates a single thread” => “but only ever operates a single thread”

“You can create an Enumerator object by calling the to_enumethod” should say “to_enum method”

“manually scheduling threads without involved any …” should read “involving”

“it uses native operating system, but only ever operates a single thread at a time” should (I think) read “uses native operating system threads”

“You’ll never see two thread in the same application” should read “threads”

“By calling join on each of the requestor threads” should be “requester”, according to my dictionary (Chambers), but this may just be a US versus Australian/British English difference.

“What’s more, these rules changes significantly with Ruby 1.9” should read either “change” or “changed”.

“…(an implementation in Java from runs of the JVM),..” should be “that” instead of “from”

Towards the middle of the page, there’s a sentence, “For now, the code is the block is not executed.” It looks like it should read, “The code in the block”.

Change “def MyLogger.create” to “def self.create” - since somewhere before this page you wrote that this is the new/preferred/modern idiom.

In note 1 at the bottom of the page, the phrase “Development versions of the software had off minor version numbers…”. The word ‘off’ should be ‘odd’.

In “We could fix this by writing a class which reads the file and yields each successive work.” “work” should be “word”.

The 1.9 note on the new literal hash syntax says “in fact hashes are so frequently used that 1.9 introduces a new hash syntax.”

I don’t think thats the motivation. The real motivation is for use of hashes as keyword parameters to methods.

I’d suggest changing this to something like “Ruby 1.9 has introduced an additional syntax for hashes which is more compact …”

At the bottom of this page (tagged with 1.9):

“Do this by prefixing the array argument (which must follow all the regular arguments)”

then on the next page examples which include splat parameters anywhere in the parameter list, and the following:

As of Ruby 1.9, splat arguments can appear anywhere in the parameter list, and you can intermix splat and regular arguments.

First paragraph:

“Ruby also guarantees that n matter…” — should be “no” not “n”

This describes a 1.9 feature, but doesn’t have the little icon on the side of the page. Should add…

“Alternatively, the module could use a module-level hash, indexed by the current object ID, to store instance-specific data without using Ruby instance variables.” It should be useful to add a warning for this way : the instance-specific data will not be removed if the GC kill the object…

While the code at the bottom of the page works (samples/tutstdtypes_12.rb), it’s not clear (to me at least) why. Why does there have to be a comma between the two opening ’<<’s? Why can’t you nest them so STRING2 terminates before STRING1? In general, it seems to be a more complicated example than you are trying to get across I think it either needs simplifying or more explanation.

PS Submission form doesn’t seem to work with Opera

The method prototype contains a type “_tring” when you mean “_string.”

str.squeeze( < string > ) → squeezed_tring

Should be

str.squeeze( < string > ) → squeezed_string

In the text towards the bottom of the page you say,

“You can also prevent anyone from changing a particular object by freezing it (we talk more about freezing objects on page 413). Attempt to alter a frozen object, and Ruby will raise a TypeError exception.”

But when you run the example code, a RuntimeError is raised. The above text is incorrect and should read:

“You can also prevent anyone from changing a particular object by freezing it (we talk more about freezing objects on page 413). Attempt to alter a frozen object, and Ruby will raise a RuntimeError exception.”

Chapter 28 (extending ruby) doesn’t discuss the treading model in 1.9, and the big VM lock. I think this is a big change, and should be addressed, so people can write better extensions.

Excerpt from ko1:
See rb_thread_blocking_region() in thread.c.

rb_thread_blocking_region(
rb_blocking_function_t *func, void *data1,
rb_unblock_function_t *ubf, void *data2)

func() is your function which you want to do without GL. YARV
release GL and call func(). If func() returned, YARV acquire GL and
continue ruby program.

ubf (unblocking function) is called when another thread interrupts
this thread with Thread#kill, or main thread exits. You must set
ubf as interrupt function for func(). You must write ubf or ruby
will not exit until func() ends.

The release notes say you’ve changed from, the One-Click to the ruby-lang.org version, but this page still points to the One-Click

The sentence just after the code example beginning “class Client” ends with “when if the object is deleted”.

Could you please include a few pages on the use of SQLite with Ruby in the 3rd edition of “Programming Ruby”? Or some other database that doesn’t convert all of it’s keys into strings? (You mention MySQL, but it isn’t yet in the index, and the mentions seem to be en passant.)

I would prefer SQLite, because I want to have local db files that aren’t system wide. Even using libdb (nee SleepyCat’s Berkeley DB) would be preferable (though I note that Python access to libdb seems to insist that keys be strings unless you are ordering the DB by record number).

That said, I realize that there doesn’t seem to be much available on the web about using SQLite with Ruby (i.e., I haven’t found anything useful), so it might not be feasible without writing a C interface.

(Dave says: Charles: there’s an Sqlite GEM that gives you a decent interface. The book really doesn’t have time to discuss all available libraries—I’m already in to hernia territory)

FYI: This is only a suggestion. I really like the book. My criticism is meant only to help you make the book better (at least in my eyes).

You could use a more consistent parallel construction when writing about the four parts. That is, start a major paragraph with the PART #. Just skimming the page I can immediately see Parts I, and III, but for II and IV I really have to stop and look to find them. I’m not a great reader and want to find particular technical info without having to read lots of text—so a consistent structure helps me.

The change could be as simple as (I’ll do the whole thing):
In Part I, …;
And Part II, …;
And Part III,…;
And Finally Part IV,…

“This kind of hands-off manipulate of Ruby programs from within C code is easy, but it has
wo major drawbacks.”

should say “manipulation” and “two”

In first paragraph of section “Symbols”, “reference to the compass points” should be “refer to the compass points”.

“We could fix this by writing a class which reads the file and yields each successive word.”

Should that be “writing a method” instead?

you should add the “Ruby One-Click Installer for Mac OSX” to your list of osx ruby distributions. see the project on rubyosx.com — furthermore, there is a one-click installer for ruby 1.9 for osx in development, soon to be released on rubyosx.com.

(Dave says: I will when it supports 1.9)

missing space:

to_enummethod should be to_enum method in the paragraph just above the code example

Putting defined? and the logical operators into one heading is confusing and unnecessary

There is no such thing as “8-bit ASCII”. I understand that Ruby has an encoding “ASCII-8BIT”, but this term is going to confuse readers into thinking there is such a thing. You may have to say early what ASCII-8BIT is about (i.e., ASCII with a promise that non-ASCII characters won’t be interpreted).

(Dave says: I believe I go on to explain just that…)

The bookmark for Unit Testing, under Part I—-Facets of Ruby takes you to page 182, but the chapter actually starts on 181.

The description of the private method Object#remove_instance_variable uses an example which implies that the removed instance variable is set to nil.

In reality this method actually undefines the instance variable and then calling the attribute reader re-defines it.

The example would be better as:

class Dummy
def initialize
@var = 99
end

def remove
remove_instance_variable(:@var)
end

def var_defined?
defined? @var
end
end
d = Dummy.new
d.var_defined? # => “instance-variable”
d.remove # => 99
d.var_defined? # => nil

typo: esxception

typo: minnax instead of minmax in method name, also minmax “call template” contains “min” instead of “minmax”.

The “call template” is also wrong for minmax_by and min_by.

description of identical? method has bogus “in Table 26.3 on the following page” in the text as last sentence.

Description of File.new is bit unclear with respect to “modestring”. The referenced table (26.6 on p. 478) doesn’t talk about encodings, even though the text suggests it will.

Also, what happens with encoding if you use integer as modenum is not explicitly mentioned in the text.

(Dave says: IO hasn’t yet been updated. When it is, the table will contain what you need)

Return value in “call template” for both world_readable? and world_writable? doesn’t correspond with the return value mentioned in method description. Which one is it, then? “bits or nil” or “true or false”

Would
it be possible to add “next” link to every 1.9 flag in the PDF beta
book? Would make sequential scanning for things changed in 1.9 much
easier. :-)

(Dave says: that turns out to be a tad difficult because of the way the flags are added (don’t ask. I personally just use the search facility in my PDF viewer)

In description of Hash.compare_by_identity is typo in sentence “… if hey are the object.” Btw, even with s/hey/they/ it doesn’t make much sense to me. How about adding “same”?

Hash.key — typo in description: “hte” (should be “the”).

Hash.rassoc description, missing description of what is rassoc looking for: “Searches hsh for the first element whose value is (((blank))), returning…”

In the first sentence after the header “Source Encoding is Per-File”, build should be built.

“the the” should be “if the” in the sentence that begins “You have to be careful…”

Simple typo

Ruby actually comes with more encodings that those shown in the output from this code.

Should be “more encodings than…”

Could you give detailed information on the reserved word undef?

(Dave says: I’ve made a note to document it in the languages chapter)

Fourth paragraph in “self and Method Calling” section reads “If is can’t find the method in the class, it looks in the class’s super class” … should read “If it”

IMHO, the graphic on the page should have a link from String.super to Object and another from String.class to Class, but not from String.class to Object.

in the to_s method of KaraokeSong it should be:
super + " #{[lyrics]}" but it says super + " [lyrics]"

You just missed the #{} block

Best Regards
Lars Söderström
Sweden

(Dave says: it’s actually correct as is)

Looks like we’re missing the initial definitions of accessors for Song artist, name and duration.

The text goes straight from “… the first thing we may need is the ability to find out the title and …” to samples/tutclasses_11.rb which shows the accessors being used. It then moves on to describing the ‘attr_reader’ shortcut, but i don’t see the long hand definition anywhere.

I am learning about meta-programming, and you have a diagram showing anonymous proxy classes that Ruby uses when mixing in a module at the top of page 356 - Figure 23.4

I don’t know if it is a typo or not, but I don’t think both anonymous classes would be anon1, this implies they are the same object. I could see how that could be possible in _this_case, but not if the albumn class inherited from some class that is not Object.

So I think the anon1 that Song now uses as a Proxy class should be called anon2.

Mikel

End of the second paragraph: …(with other implementations waiting in the wings and ot yet released)

Fifth paragraph: three problems here.
Rubinius is interesting—it uses the original Matz Ruby parser, but containsa totally different
VM implementation. Its goal it to have code run so fast that it is possible to write the
majority of Ruby’s libraries in Ruby itself (rather than having, for example, the String class
written in C, as it is in MRI). Right now, it looks like they might be able to achieve this,
while will be a major win for portability and extensibility.

There’s no mention of RubyGems in the Contents. It might be good to have the actual word in the Contents somewhere.

Next to last paragraph, second sentence: “It also provides integration into Ruby so that your programs can access gems are libraries. ” s/b “…as libraries.”

Other times, though, it isn’t appropriate to use
subclassing, either because we already have to subclass some other class or because or
design esthetic rebels against making something like a song a subclass of a logger.

Typo: “or design esthetic” should read “our design esthetic”

The return value from Struct.new(…) is a class object. By assigning it to the constant Person,
we can thereafter use Parent as if were any other class.

Typo: “we can thereafter use Parent as if” should read “we can thereafter use Person as if”

You can also make the turtle raise an lower a pen.
This should read: You can also make the turtle raise and lower a pen.

Heading:
“Gems Can Be More That Libraries”

Penultimate paragraph on the page:
"You can do this from source, our you can use a package
management system.

“As of Ruby 1.9, lock parameters are no longer in the same scope as local variables. This may cause compatibility problems with older code. Run with the -w flag to spot these issues. ”

should be:

“As of Ruby 1.9, block parameters are no longer in the same scope as local variables. This may cause compatibility problems with older code. Run with the -w flag to spot these issues. ”

There is an extra “the” in the sentence:

“class methods are defined by placing the either the class name or the predefined name self,”

Last line before last example (tutthreads_14.rb)

“[…]allowing other to US it[…]” should be
“[…]allowing other to USE it[…]”

samples/web_7.rb

1. instance_method
2. class_method (old way)
3. and another_class_method (new way)

sample:tutclasses_32.rb
adding @cleared_balance = balance into initialize method is make it more clear.

Misspelled word:regaulr -> regular

“Once you use named matches in a particular regaulr expression”

Last line of penultimate paragraph on the page:
" in which case it matches just before the \
."

samples/tutstdtypes_46.rb The code need:
a = ‘red ball blue sky’

The penultimate sentence in the explanation of []= at the top of the page contains “(Prior to
Ruby 1.9, assigning nil deleted the corresponding array element; no it simply assigns nil to them.)” when it should end “now it simply assigns nil to them”.

Perhaps there should be mention of the Python-like syntax when introducing printf: the example given towards the bottom of the page could also be written as ‘puts “Number: %5.2f,\
String: %s\
” % [1.23, “hello”]’

(Dave says: I think that would add complexity here)

WHAT SECTION:
"You can provide parameters to the call to yield: these will be passed to the block. Within the
block, you list the names of the arguments to receive these parameters between vertical bars
(| params… |).

def call_block
yield(“hello”, 99)
end
call_block {|str, num| … } "

SUGGESTION:
Provide a working code example for this concept. This idea isn’t clear to me. While I see that you are showing flexibility in the ability to send params to the yield. Using the snippet and trying to understand the description I was not able to create a working example of my own.

Sentence missing the word “are”. It should be “First, all the rvalues are evaluated…”

Original sentence:
First, all the rvalues evaluated, left to right, and collected into an array (unless thay are
already an array).

“RUbyGems” should be “RubyGems” in the middle of the page.

“If Ruby sees the sequence sequence \\xEF\\xBB\\xBF at the start of a source file,”
should be:
" If Ruby sees the sequence \\xEF\\xBB\\xBF at the start of a source file,"

The code might be:

1. encoding: utf-8
   while line = gets
   result = line.gsub(/\\dots/, “…”)
   result = line.gsub(/ . . . /, “…”)
   puts result
   end

The checking list should start with capitalized letter(list 2 and 3).

“and the second is the internal incoding.”
should be:
“and the second is the internal encoding.”

“transcendental functions defined my the math module”
‘my’ should probably be ‘by’

On page 62 (Class Methods), using “self.method_name” is referred to as the “modern idiom” for defining class methods. Page 83 (Blocks for Transactions), however, defines a class method on “File” using the “ClassName.method_name” syntax.

I think it would be better to stick with the “modern idioms”. This may be in other places also (you can use regular expressions (see chapter 6, page 104) to search and replace :).

Splats and Assignment, first paragraph, “consitutent” should be “constituent”

2nd to last sentence on the page, missing the word “it”:

By assigning it to the constant Person we can thereafter use Person as if were any other class.

DEADLOCK! There should be an “unlock” call in the main thread (using “ensure”) of examples “tutthreads_13.rb” and “tutthreads_14.rb”.

Based on the sentences on the rest of the page, I believe the directory name should be 1.9.0, not 1.9.

% gem environment gemdir
/usr/local/lib/ruby/gems/1.9

“how to we tell” should be “how do we tell”

Original sentence:
Now that we have both versions installed locally, how to we tell our legacy code to use
the old one while still having our new code use the latest version?

“it’s” should be “its” since you want the possessive version, not the contraction for “it is”.

Original sentence:
However, calling rake a build utility is to miss it’s true power.

Second paragraph, “executes” should be “executed”

Line 3 of paragraph 5:
At some point you’ll probably want to read ?? on page ?? to see exactly how arguments in

not sure if this counts as erratum or not, but it seems that a page reference is missing… :)

(ps, love the book. many times over.)

(Dave says: this gets fixed as I add new content)

It appears that Enumerable’s each_cons and each_slice are identical. If they are, could you make a note in the book that they are synonyms?

(Dave says: they are different: slice never repeats elements from the original array, where cons uses a moving window)

I’ve been writing some recursive Ruby 1.9 code lately — I have to be careful to know which methods return new objects and which return references to existing objects. I thought it might help others to point out something interesting about Array#last. ‘last’ with no arguments returns a reference. ‘last’ with arguments returns a new object. On the surface, this seems confusing, but perhaps there is a pattern to be found? Dave, perhaps you could say a few words about this?

(Dave says: these kinds of things are optimizations, rather than part of the language. I wouldn’t rely on them, particularly not if you want to run across multiple Ruby implementations.)

“the actual numeric values of these contants is irrelevant” -> constants

I really like your motivation and explanation for Symbols… “Symbols are simply constant names that you don’t have to predeclare.” I would tack the following on to that sentence: “…and will be guaranteed to be unique.” This way, you ‘close the loop’ and connect to your previous statement of “the actual numeric values of these constants is irrelevant (as long as they are unique)”

a = [ “a”, “b”, “c”, “b” ]; a.find_index(“b”) did not work for me: “ArgumentError: wrong number of arguments(1 for 0)”

%w(a b c b).find_index {|i| i > “a”} does work

(Dave says: are you running a recent 1.9?)

Table 3.1 seems to be in the wrong place. Should it not be better to display the table before the heading “Arrays and Hashes”?

(Dave says: we do layout at the very end, so this will get moved at that point)

2nd line reads “…with a roc which will take from zero to n arguements. ” Proc is missing a P

The last line of the “Extracting Matches to Local Variables” section ends with “(which macthes am) as $3.” which should be “(which matches am) as $3.”

In the Singleton section there is the following explanation for using an instance variable:

“Well, remember we said that just about everything in Ruby is an object? Classes are objects in their own right. Here we’re using an instance variable of the MyLogger object.”

I’m just learning Ruby, but to me it seems that last sentence should be:
“… instance variable of the MyLogger class object.”

And maybe you could add an extra note about the create() method and the @logger variable not being available from the object that create() spits out?

The definition of the DEFAULT prompt mode seems incorrect:

Download samples/irb_9.rb
IRB.conf[:PROMPT_MODE][:DEFAULT] = { …

Should be:
IRB.conf[:PROMPT][:DEFAULT] = { …

In the description of Part II, it says “creating GUI applications using Tk”, however, the release notes for B 1.03 say that the tk chapter has been removed.

In the shaded box, titled “The Very Latest Ruby”, the last sentence in the second paragraph should end with “Subversion commands” instead of “CVS commands” as it does now. I’ve also noticed on the ruby-lang.org website, it mentioned that the ruby language developers are using CVS for revision control. Kind of confusing…

to get information for a particular method in GC class, you should include the class name as part of the parameter:

suggested fix: ri GC::enable

1. => will return the correct information for GC::enable method

error found: ri enable

1. => will return a message stating that they are more than one method matching the request

(Dave says: probably only if you have other gems installed containing an enable method.)

In the example 2/3 of the way down the page, you write " If a variable appears both in the block and in the surrounding scope", but in the actual code in the .pdf, element and c are only defined inside the block, not outside.

Michael Rogers (mprogers@mac.com)

(Dave says: this section has been rewritten)

“Leopard (OS X 10.5) come with Ruby 1.8 preinstalled. Both work fine out of the box” Come or comes?, Both what?

The Complex class extends regular numbers with come convenience methods

should be

The Complex class extends regular numbers with _s_ome convenience methods

I’d strongly recommend a mention of Mauricio Fernandez’s fastri as a much improved version of the standard ri

aitch tee tee pee slash slash eigenclass.org/hiki.rb?making+ruby+ri+faster

(Dave says: doesn’t seem to run on 1.9:

dave[RUBY3/Book 0:48:25*] fri String
/usr/local/rubybook/lib/ruby/gems/1.9.0/gems/fastri-0.3.1.1/lib/fastri/util.rb:38:in `require’: no such file to load — rdoc/ri/ri_paths (LoadError)
\tfrom /usr/local/rubybook/lib/ruby/gems/1.9.0/gems/fastri-0.3.1.1/lib/fastri/util.rb:38:in `<top (required)>’
\tfrom /usr/local/rubybook/lib/ruby/gems/1.9.0/gems/fastri-0.3.1.1/bin/fri:6:in `require’
\tfrom /usr/local/rubybook/lib/ruby/gems/1.9.0/gems/fastri-0.3.1.1/bin/fri:6:in `<top (required)>’
\tfrom /usr/local/rubybook/bin/fri:19:in `load’
\tfrom /usr/local/rubybook/bin/fri:19:in `

“authentification”? Perhaps authentication?

Word also appears on page 886: “APOP authentification”

“…within and of the ranges…” Something got botched here. Maybe “…within the ranges…” ?

(Dave says: if should be “any of the ranges”)

In the second paragraph, first sentence there is written “Song object”. This should read “BookInStock object” now that the tutorial has been changed.

(Dave says: I’ve removed the whole section)

Under the “Writable Attributes” section, in the paragraph right beneath the Java setter/getter example, there is a mention of “song.name”. Instead, this should read “b1.isbn” or “b1.price”.

Right under the “produces” italized text the line should read:

“Processing data.csv
Total value = 122.07”

Instead of:

“sh: line 0: cd: code/sales.data: No such file or directory”

“Type typing echo hello at the prompt and hitting enter (or return, depending on your keyboard.”

near the bottom of the page in The Command Prompt section should be …

“Type echo hello at the prompt and hitting enter (or return, depending on your keyboard.”

OX X in Directories, Folders, and Navigation section should be OS X

It shows an example of using ri to find the details of the method of GC as an example. Here “ri enable” command gives lots of alternatives and “ri GC.enable” does not work as pointed out in the book. However “ri::enable” works..

I am using ruby 1.9.0.

C:
projects
time_planner
readme.txt on Windows.

should read …

C:\\projects\\time_planner\\readme.txt on Windows.

At the bottom of page 46 it says that keys in a hash must be unique.But in the histogram example in the middle of page 47 you give an example of counting the number of times a key occurs. By rule no key could occur more than once but your example shows the same key occuring 3 times. This is very confusing.

(Dave says: the keys represent the things being counted and the value is the actual count, so each key is unique. I’ve reworded the example.)

“but, unlink a method, those parameters appear at the start of the both between vertical bars”:
1. “unlink” should be “unlike”
2. Typo “at the start of the both between” (perhaps “both” should be “block”?)

“via the RSTRING macros.This is a change in Ruby 1.9—prior to this you manipulates the C structure directly.”
1. Need a space before “This is a change”
2. Typo “you manipulates” should be “you manipulate”

In the code example for class CsvReader, the body of the foreach block contains the following line of code:

@books_in_stock << BookInStock.new(row[“ISBN”], row[“Amount”])

Then in the second paragraph following the class CsvReader example code, the first sentence refers to: “…the ISBN and Price columns,…”.

Perhaps Price should be changed to Amount in the explanation, or “Amount” should be changed to “Price” in the code example?

Inconsistent reference to Song (from a previous version of the book, IIRC):

“Our experience tells us that during development we’ll be printing out the contents of a Song object many times, and the default formatting leaves something to be desired. Fortunately, Ruby has a standard message, to_s, that it sends to any object it wants to render as a string.
So, when we pass one of our BookInStock objects to puts…”

The text then goes on to define a to_s method on BookInStock, so I think the reference to Song just didn’t get converted over to BookInStock.

At the end of the page :

“The first, book_in_stock.rb, will contain the definition of the class
BookInStock. The second, csv_reader*, is the source for the CsvReader class. Finally, a third
file, stock_stats.rb is the main driver program.”

• : You have forgot the .rb to the file name cvs_reader.

Good Day

The opening paragraph on Containers talks about examples where containers (like arrays) would be useful. One of those given is “the people in a class”. I’m a seasoned rubyist, but I still hit a minor mental bump processing that. The previous chapter was all about Ruby Classes, and people new to the language may not immediately discern the different context of class as a group of people getting in training. It would read more clearly if that specific example was changed to “people in a room” or “people in a life raft”.

Comments in example code on this page and on p.62 says the book price will be discounted by 75% but price will in fact be 75% of the original price i.e. reduction is 25%.

Some typos on p.52, last para above code: “followin” should be “following” and “it’s” should be “its”.

Also last para on p.60 - “The corresponding instance variables are isbn and price. automatically.” Respectively perhaps?

Enjoying Ruby and the book very much, thanks and best wishes,

Michael Drysdale
drysdale@gmail.com

The color schema of class illustrations (lime on yellow) correspponds very poorly with the page boundaries color (a tint of red)

At the bottom of the page:
“The followin example shows a method calling it’s associated block twice”

should be: “The FOLLOWING example shows a method calling it’s associated block twice”

(missing a G in following)

Start of second paragraph says:
“Our experience tells us that during development we’ll be printing out the contents of a Song object many times”

should read:
Our experience tells us that during development we’ll be printing out the contents of a BookInStock object many times

(should be BookInStock instead of Song)

When creating the instance of BookInStock:
book = BookInStock.new(“isbn”, 12.34)

change the isbn number to an actual isbn number (perhaps the one for this book). Because when the sample output is shown later on the page:
ISBN = isbn
Price = 12.34

It may seem like puts “ISBN = #{book.isbn}” is just printing out the name of the instance variable, not the value of it (obviously the Price right below it shows that it is printing out the value, but for clarity I think using an actual ISBN would be helpful)

The last line of the Java code example says:
b.setDuration(calculate_discount(b.getPrice());

It should read:
b.setPrice(calculate_discount(b.getPrice());

(setPrice instead of setDuration, looks like a leftover from the Song example)

Towards the top of the page, it says:
The first and last methods return the n entries at the head or and of an array without removing them.

should read:
The first and last methods return the n entries at the head or END of an array without removing them.

(‘and’ should be ‘end’)

String.to_r is not available in the default ruby1.9 installation (ubuntu 7.10) or 1.8.6 (exact versions below).

I have verified this with
ruby 1.9.0 (2007-08-30 patchlevel 0) [i486-linux]
ruby 1.8.6 (2007-09-24 patchlevel 111) [i386-mswin32]
ruby 1.8.6 (2007-06-07 patchlevel 36) [i486-linux]

This function may just need to be tagged 1.9 since you are most likely using a later version of 1.9.

show_regexp(a, /[\\d\\]/) # => see [Design Patterns<<->>page 123]

I think this would actually yield “No match” and not “see [Design Patterns<<>page 123]“. The ”” is not preceeded by a digit.

(Dave says: the actual pattern is [\\d\\-])

the final ‘end’ which ends the ‘else’ of the “If and unless expressions” example need to come before table 8.1

Right now Table 8.1 appears with a random ‘end’ statement immediately after it.

(Dave says: we do layout when the content is complete)

At the bottom of the page: “it’s associated block twice” should be “its associated block twice” (its, not it’s)

In the text, where you have: “We’ll do that later, in 10 on page 155.”
Shouldn’t this be: “We’ll do that later, in chapter 10 on page 155.”

In the table of contents, the “Array” and similar sections are on the same level than the “Built-in Classes and Modules” section, thus, it is impossible to fold all built-in classes to show only the standard library classes.

The built-in classes should be a subsection of the “Built-in Classes and Modules” section.

Also, the naming in table of contents is somewhat strange, e.g. “Array” is named in the toc “4-1Array”.

In case something is unclear, you can mail me at giga@le-pec.org.

Thanks for your hard work.

In the book, the output of running the program:

$ ruby stock_stats.rb data.csv

is an error:

produces:
stock_stats.rb:1: undefined method `require_relative’ for main:Object (NoMethodError)

To be clear: this error was included in the book’s text at generation time.

(Dave says: d’oh—the book ran it with ruby 1.8 in error)

“Ruby comes with a library called GServer than implements basic TCP server functionality.”

Should be:

“Ruby comes with a library called GServer THAT…”

“Then, when a client connections,”

should be:

Then, when a client CONNECTS,"

In stock_stats.rb, STDERR is used to print the file being processed (STDERR.puts “Processing #{csv_file_name}”). Isn’t it better to use STDOUT?

(Dave says: I use STDERR for status messages, because STDOUT is typically used to pipe real data between programs)

‘tp’ in the second-to-last line of the description of Process.daemon should be replaced by ‘to’.

Closing bracket is missing for : “We were
then able to perform comparisons (such as p1 > p2 and even sort an array of Person objects.”

In the paragraph following the shaded box says:
…we didn’t have to enter the pull path
should say:
…we didn’t have to enter the full path

Says:
IN the previous chapter we saw that that when
Should say:
In the previous chapter we saw that when

The bookmark “Inheritance and Messages” does not lead to that section on page 72 but links to the box “Inheritance and Mixins” on page 78

“We can work out why to_s is available in just about
Ruby object.” should probably be “… just about every Ruby object”

the word “out” should be “our” in the following text block:

Now let’s look at the library files. We know we’re going to be defining (at least) three
classes. Right now, these classes will be used only inside out command-line program, but
it’s conceivable that other people might want to include one or more of our libraries in their

last paragraph, second to last sentance:

Using Rake means that the GemSpec will be packaged with a set
of tasks that you can use to build you Gem.

final “you” should be “your”.

Page 82 references “Back on page 100”, but goes to a different page which doesn’t seem to contain the referenced inject method

Inside the box at the top of the page, in the third sentence: “a class wih no name” should be “a class with no name”.

The code uses the Shape class, but the comment refers to the Square class.

Second sentence of Module#constants:
“With on argu-ment” should be “With one argu-ment”

Also, the parenthetical comment at the end of the sentence is missing ‘)’.

I’m somewhat new to ruby, but not to programming. It looks as though there’s an extra “person2” in the code listing on page 69:

person1 = “Tim”
person2 = person1
person1[0] = ‘J’
puts “person1 is #{person1}”
puts “person2 is #{person2}”
person2


I think that person2 at the end should go away.

Book says: “Combine unshift and push and you have a first-in first-out (FIFO) queue.” But example below it uses shift instead of unshift (and appears to be correct.) So preceding explanation is in error.

Simple typo:
“But as you programs grow…” should probable be “But as your programs grow…”

(actually a layout type, but that was not on the list)

The footnote on page 184, concerning primitive Thread operations, is not aligned very nicely.

“The method superclass method returns the parent of a particular class.”
duplicate use of the word “method” in this sentence.

“If you want to include the literal characters ] and - within a character class, put the at the
start or escape the with \\”

That sentence on the page is missing something. Put the “what” at the start, or escape with a \\.

The foot note on this pages suggests an exercise to the reader to extend the method to handle Double-Barreld and apostrophied names. I don’t know if it was intentional or not, but the code already handles that. So it’s not much of an exercise ;)

Middle of page: change
“we show the value of expressions as on the same line as the expression”
to
“we show the value of expressions on the same line as the expression”

Below 2nd code sample, text reads:
“Note that if you simply run this program, you wouldn’t see…”

How about:
“Note that if you were to simply run this program, you wouldn’t see…”
or
“Note that if you simply run this program, you won’t see…”

4th paragraph: “(or return, depending on your keyboard.”

open paren without matching close paren

Last paragraph: change “a graphic tool such as Explorer” to “a graphical tool such as Explorer”

3rd paragraph: “we’ll just using a single dollar sign” should be “we’ll just use a single dollar sign”

In code examples on this page, the windows versions of the commands use forward slashes rather than backslashes. I just tried this on a windows xp machine to make sure, and it does not work.

3rd paragraph: change “use apt-get system” to “use the apt-get system”

“MISSING:” tag says, "Currently 1.9 is not available. Autogenerated text on page 20 says this version was built with ruby version 1.9.0.

1.9 is not available as a package. I install via SVN from source

The last paragraph (a partial) begins:

This example is not particular compelling…

It should be:

This example is not particularly compelling.

Last paragraph, last sentence reads: “When a string containing a newline is output, the \
forces a line break.”

For consistency, how about:
“When a string containing a newline is output, the newline forces a line break.”

Last paragraph ends with a double period (“..”)

After reading the first paragraph on this page, I find myself wondering, “Can the string position be 0? If so, would that evaluate to false in a conditional, even though it matched the regular expression?” Please add a satisfying answer!

Dave says: 0 is not false. We cover conditionals elsewhere

Last paragraph, first sentence: “Why are there two kinds of delimiter?”

I’m not sure if “delimiter” should be pluralized here or not…

3rd paragraph, last sentence reads, “You can think of yield as being something like a method call that calls out to the block associated with the method containing the yield.”

I think it would be more correct if this said, “You can think of yield as being something like a method call that calls out to the block associated with the call to the method containing the yield.”

(added “call to the” to emphasize that the block is associated with a method call, not with the method itself)

5th paragraph: “When we run it with arguments, we can see them getting passed in”

This seems to say that we are getting a behind-the-scenes look at the process of passing them in, which seems a bit confusing to me. How about something like “We can run it to see all the arguments that were passed in” instead?

2nd-to-last paragraph: “a good first step it to” should be “a good first step is to”

2nd-to-last paragraph, last line: change “by the time that initialize returns” to “by the time initialize returns”

Last paragraph, end of 2nd line: “the two variables here, isbn and isbn are somehow related" needs a comma after "isbn and isbn”.

2nd paragraph, 2nd-to-last line: “get it’s string representation” should be “get its string representation”

3rd paragraph, end of 2nd line: “and then available” should be “are then available”

3rd paragraph, last sentence: “each object” doesn’t agree with “those objects”. How about changing “those objects” to “that object”?

(Dave says: correct as stands)

It looks like you’re trying to keep a clean set of numbered “tutclasses_##.rb” files. But it seems a little strange that we have a java class here in an .rb file.

It looks like you’re trying to have a cleanly numbered set of “tutclasses_##.rb” files, but in the example on this page we’re calling the files by one set of names in the text (book_in_stock.rb, csv_reader.rb, and stock_stats.rb) and another set of names in the caption starting each code sample.

I’m very sorry for the inconvenience.)

In the second code example, the “def total_value_in_stock” line and the comment right above it are indented too much.

3rd paragraph, 2nd-to-last line: “monlithic” should be “monolithic” and “won;t” should be “won’t”

Not sure about this one, but in last line of first paragraph under “Access Control” heading, how about changing “A good rule of thumb is never to…” to “A good rule of thumb is to never…”

(Dave says: I wasn’t raised to arbitrarily split infinitives :)

Last paragraph, 2nd sentence: 2nd use of “may want to” sounds redundant - consider eliminating it.

2nd paragraph of “Variables” section, last line: Shouldn’t “string” be capitalized to match the other uses above that are capitalized?

(Dave says: if I’d said “take on the properties of String”, then I’d agree. Here I think lower case is better)

Last paragraph, 3rd line: change “take away that fact that” to “take away the fact that”

2nd-to-last paragraph, 2nd line: “Now also that” should be “Note also that”

I’m curious why “.superclass” is used in the first three code examples on this page, but the fourth uses “.superclass.inspect” - if there’s a reason for this, could you include a short explanation?

(Dave says: try it without :)

2nd-to-last paragraph: “So, by the time our initialize method finished, our LogServer object will be…”
should be:
“So, by the time our initialize method FINISHES, our LogServer object will be…”

End of 2nd-to-last paragraph: “we start and join to this server.” I understand starting a server, but this has me wondering what it means to “join to” it.

Last line: “its our code” should be “it’s our code”

First line: change “the last few lines of log file” to something like, “the last few lines of the system log file”

Start of 2nd paragraph: “The use of the server method” should be, “The use of the serve method” (that’s the name of the method in the code example)

2nd paragraph, 2nd line: “expects it children” should be “expects its children”

2nd paragraph: might it be clearer if “expects its children to implement” was instead something like, “expects its children to override”?

(Dave says: the parent doesn’t contain any implementation, so there’s no overriding)

End of 3rd paragraph: “we ll” should be “we’ll”

First sentence: “Module constants are named just like class constants, with an initial uppercase letter.”
It looks like they are named with all uppercase letters, not just an initial uppercase letter.

The last paragraph on this page is somewhat confusing when it talks about modules having “instance methods”. If a module can’t have instances, can we talk about it having instance methods? Would modules with “self.” prefixes become class methods when mixed into a class? Is it legal to have “self.” methods within a module? If so, what do they mean if the module is used directly, rather than as a mixin?

This paragraph seems to introduce some comfusing wording and some unanswered questions!

(Dave says: they’ll be answered soon…)

The section “Iterators and the Enumerable Module” seems like it is in the wrong place. It starts: “You’ve probably noticed that the Ruby collection classes support a large number of operations that do various things with the collection: traverse it, sort it, and so on.”
I don’t think that having read up to here, I’m in a position to have noticed that. After all, containers are introduced in earnest later, in Chapter 6.

Last paragraph, 2nd line: change comma after “arithmetic sum” to a semicolon.

(very minor) Spacing would look more consistent if “( ‘a’..‘m’).sum” were instead “( ‘a’..‘m’ ).sum”

The body of the middle method (“observers << obj”) looks wrong to me, since there isn’t a observers= setter method. Should this be “@observer_list << obj” instead? Or should there be a setter? If it’s correct as written, an explanation would help.

(Dave says: it;’s a call to the observers method defined above it)

2nd-to-last paragraph, 1st line: “In the past, we’re tended to” should be “In the past, WE’VE tended to”

2nd-to-last line: “if code that uses objects of the child class rely on…” should be “if code that uses objects of the child class relies on…”

Near top: “Instead need to” should be “Instead WE need to”

3rd paragraph: “And that’s where a combination of mixins and metaprogramming come to the rescue” should be “And that’s where a combination of mixins and metaprogramming COMES to the rescue”

End of 3rd paragraph: “They let us say”
Right before this the subject was “a combination of mixins and metaprogramming”, so my gut says this should read something like, “This lets us say”, or maybe “these techniques let us say”

2nd paragraph: “classes that gives Ruby its power” should be “classes that GIVE Ruby its power”.

(Dave says: I think the subject is singular (not classes))

2nd paragraph: change “When paired with collections, these blocks…” to “When paired with collections, blocks…” (‘these’ seems unneccessary)

Last paragraph: “shift and unshift add and remove elements…”
I’m pretty sure shift removes and unshift adds, so how about switching the order of either “shift and unshift” or “add and remove”?

With this discussion of arrays vs hashes (aka associative arrays) I’m curious about the implementation of arrays vs that of hashes, and whether I should be mindful of performance implications. For example, if I do something like “a[1000000] = 5” would that create a c-style array in memory with a million and one elements, the first million of which are nil? Or should I think of it more like a hash, performance-wise?

In the last few code samples, the differing numbers of dots (“…..” vs “…”) looks odd to me

2nd line: “the test unit framework” should be “the TestUnit framework”

End of 2nd paragraph: “an array or two-element subarrays” should be “an array OF two-element subarrays”

2nd code example introduced with: “some Ruby programmers might write this more compactly as”
But this version looks like it doesn’t do the same thing. Its output would be an array of strings, while the sample above would output each string on its own line with no array.

(Dave says: try it…)

2nd paragraph, 2nd line: I think this would be clearer if “in the same scope outside the block” were changed to “in the scope outside the block” (removing “same”)

3rd paragraph, last line: I think this would make more sense if “square is not defined at that point” were changed to “square is not defined before the block”.

4th paragraph: “unexpected programs” should be “unexpected problems”

Start of “Implementing Errors” section: “A Ruby iterator is simply a method that can invoke a block of code. This isn’t really true (as the ”Blocks for Transactions" section on page 102 explains). How about something a little more descriptive like, “A Ruby iterator is simply a method that invokes a block of code for each item in a set.”

(Dave says: the sentence doesn’t imply that every method that invokes a block is an iterator…)

I’m curious about footnote 3’s mention that “the [fibonacci] series is sometimes used in sorting algorithms” - is it used in the analysis of sorting algorithms, or is it somehow used directly by a sorting algorithm?

(Polyphase merges using the Fibonacci numbers to schedule the merges)

2nd paragraph: change “the value passed to the yield” to “the value passed to yield”

2nd paragraph describes the ‘each’ method and then an example is given. I feel like we’ve already seen this several times by now.

3rd paragraph: “starting on page 81 we’ll see how defining an each method can…”
But we’re now on page 99

4th paragraph, last line: “The following example uses the succ, which increments a string value.” What’s “the” doing here? This sentence is teh suck :)

Middle of 2nd paragraph: “There’s one final wrinkle”
“final” sounds redundant given its use the the preceding sentence. Also, the wrinkle isn’t really final - the next paragraph, a 1.9 addition, adds another wrinkle!

2nd-to-last paragraph: I think this is saying that either a string or symbol naming the method are equally acceptable when calling inject. It might help if this were made a little more explicit.

Last sentence: “The thing that uses the iterator is just a block of code associated with this method.” I think to be correct this should say something like, “The thing that uses the iterator is just a block of code associated with A CALL TO this method.”

2nd sentence: change “Instead, they generate” to “Instead, they contain methods that generate”

4th paragraph: I’m curious at this point how a method can determine whether or not it has been called without a block. After reading more, I saw that this is discussed and answered on page 103. But there is seems to be brought up as though it just came up there for the first time rather than here, two pages earlier.

Last code sample on page: I’m thinking that if I modify a with a call such as, “a[0] = 0” after creating the iterator (with “enum_a = a.each” but before using it (with “enum_a.next”), I will get a different result since I have an iterator that still references the same array a. I think this would fit the description of a closure given a little later. My suggestion is to mention at some point that an Enumerator is a closure and will give this type of behavior (or that it isn’t, if that’s the case).

Last paragraph: I had to read this part a couple times, because the earlier text had me expecting this paragraph to say that loop returns an Enumerator if it is called without a block. Instead, if talked about use of Enumerators within the block passed to loop, and made no mention of whether loop could be called without a block. I’m not sure how this should be modified, if at all, but I thought I’d mention it since it interrupted the flow for me somewhat.

End of 1st paragraph, suggested change: “whatever parameters it received” to “whatever parameters it RECEIVES”

2nd paragraph, last line: “responsibility for closing an open file has been passed…”
How about changing “passed” to “shifted”

2nd paragraph, last line: change “user of file objects” to “USERS of file objects”

End of 2nd paragraph: Changing the end of the statement “responsibility…back to the files themselves”
to
“the File class itself”
or
“the File objects themselves”
seems a little more correct

3rd paragraph: Twice in this paragraph, we have “file object” instead of “File object”

(Dave says: I’m happy with the way it is—I’m talking generically here)

3rd paragraph, 3rd-to-last line: “…if a block is associated with the current method.”
Shouldn’t this be something like: “…if a block is associated with the current method’s invocation.”

In code sample, File.new is called. On previous page, File.open was called in the same situation. Wondering if there is a difference between File.new and File.open, and why two different calls are used, or if the two are interchangeable.

(Dave says: we’ve already seen both)

In the code example, a call is made to “block_given?” after the method was just introduced as “Kernel.block_given?”.
I’m wondering at this point if the “Kernel.” prefix is implied, and indeed if Kernel is a central module or class that all the core methods in Ruby belong to, and is therefore implied in many of the method calls we’ve been making up until now.

In the code sample, we define a class method “my_open” for the File class. I’m wondering at this point if running this code sample will have the effect of adding a new method to the existing File class supplied with Ruby, leaving the rest of the class working as before.

(Dave says: try it…)

4th paragraph: “ensure that we closed files even if the code processing that file somehow aborted.”
Should be something more like: “ensure that we closed files even if the code processing THE FILES somehow aborted.”

“proc object” is used instead of the capitalized form “Proc object” twice on page 104 and once each on pages 105, 106 and 107. Wondering if this in intentional since we seem to be referring to the Proc class in all these cases…

End of 4th paragraph: “to the called.” should be “to the caller.”

Last paragraph: “Ruby provides not one, but two built-in methods that convert a block to an object. Both lambda and Proc.new…” (Footnote 6 adds that there’s a third, proc, but it is ‘effectively’ deprecated.)

…but, there appears to be another one introduced on page 106: ->
From the description it looks like procs created with -> behave like those created with the lambda method, but are more versatile in the parameters they may accept due to the differing syntax of -> and lambda.

So, that would make three built-in methods, not two (and not counting the deprecated proc method) right?

(Dave says: -> is not a method. Its syntax. Method here means code callable by name, and not technique)

Middle of page: “It [the parameter list for ->] can take default values, splat args (described on page 137), and block parameters (arguments starting with an ampersand).”

It seems like this should be reworded as, “It can take default values, a splat arg (described on page 137), and a block parameter (argument starting with an ampersand).” unless more than one spat arg is allowed and more than one block parameter is allowed.

2nd paragraph, last line: “Because the condition is passed as a block,”

It looks like the condition in the example is passed as a proc, not a block.

13th paragraph, first line, second phrase: “Do do this, we’ll create a hash object indexed” should be “To do this, we’ll create a hash object indexed”

3rd line: change “convert the string” to “convert EACH string”

2nd paragraph, line 4: more“complex” (no space between ‘more’ and the double-quote)

End of 2nd paragraph: change comma in “the result will be a float, if you mix floats and complex numbers” to a semicolon.

The sample text in the first heredoc sample would be more correct if “ending” were changed to something like “starting”

2nd paragraph: “We’ll have a lot more to say about encoding in 17 on page 247”

How about adding the word “Chapter” before the “17”

4th paragraph: “than try to remember these ones.”
Suggested replacement: “than to try to remember these.”

Looks like “Struct” makes an appearance for the first time in this code sample, with no discussion of what it does. I think it’s fairly obvious from context, partly because I remember struct from C and mostly from the output shown. It does make me wonder about the details behind Struct, though.

Last line of 2nd paragraph: change “component” to “components”

In code sample, I notice we’re calling mins.to_i and secs.to_i
On page 111, we called Integer(v1) in the same situation. Wondering if there’s a difference?

2nd paragraph: “At least one operand of the match operator must be a regular expression.”
I’m wondering what it means if both operands of the match operator are regular expressions, and when one would want to do that. I don’t think I saw an example of this anywhere in this chapter.

3rd paragraph: “We can use this to write a method…”
How about changing “this” to “these” since I think it refers to the $ variables just introduced.

4th paragraph says, “The match also sets the thread-local variables $~ and $1 through $9.”
I’m wondering, what about $&, $` and $’, just introduced in the paragraph above? Are they thread-local?

Last line: “They can also be negated by putting an up arrow after the first colon.”
I’ve never heard a caret referred to as an “up arrow”. How about “caret”?

Wondering if the “Posix Character Classes” work only for US encodings, and the “Character Properties” do the equivalent thing for all the supported encodings listed? There is very little description on pg 122 explaining this (two short sentences).

In description for [:blank:], does “Blank” mean a single space? And for the descriptions for [:graph:], [:print:], and [:punct:], does “space” mean all whitespace characters?

Dave says: Each matches one character position)

In third, fourth, and last paragraphs, “regular expression” is used as if it means something like, “expression within a regular expression”. Regular expressions were introduced on page 120 as “objects of type Regexp”. This usage sounds a little confusing.

In code sample, the line:
a = ‘red ball blue sky’
is used twice and looks a little redundant.

End of page: for the \\k’name’ notation, there’s no example given. How about changing the ‘mississippi’ example at the top of the next page to use the single quote form?

In the discussion toward the bottom of this page, I am wondering, what happens if there is a name collision with pre-existing local variables? Would those local variables simply be overwritten by the ones set by the regular expression?

5th paragraph: “They may enter DAVE THOMAS, dave thomas, dAvE tHoMas, and we’d like to store is as Dave Thomas.”

Two corrections: add an “or” before “dAvE tHomAs” and change “is” to “it”.

Last sentence: “we’ll have to wait until 23 on page 366 to see why it works.”
Suggestion: “we’ll have to wait until CHAPTER 23 on page 366 to see why it works.”

David Kowis’ comment on the code already handling Double-Barreled names and apostrophes looks to be correct if you’re using dashes separating names and names that have apostrophes in them. If you use underscores and apostrophes that indicate possession, then it doesn’t.

mixed_case(“dave_thomas”) # => “Dave_thomas”
mixed_case(“dave-thomas”) # => “Dave-Thomas”
mixed_case(“dave o’thomas”) # => “Dave O’Thomas”
mixed_case(“dave thomas’s”) # => “Dave Thomas’S”

First sentence: “You can also give sub and gsub a hash as the replacement parameter, in which case it will look up matched groups…”
Suggestion: “You can also give sub and gsub a hash as the replacement parameter, in which case THEY will look up matched groups…”

( sub(/it/, “they”) )

Page 126 talking about numbered variables such as $3, noted that “Once you use named matches in a particular regular expression, Ruby no longer bothers to capture unnamed groups.”

On this page, talking about backslash sequences such as \\3 used within an expression, I assume that same rule holds true?

In the code sample we have: md1[1, 2] # => [“12”, “34”]
Interesting notation, and don’t think we’ve seen it before. Worth a mention?

The third sentence in the paragraph beginning “Ruby has an interesting secret”, change “And than means” to “And that means”.

As of Ruby 1.9, his is no longer supported. => “his is” ???

Under “Variable-Length Argument Lists” heading:
‘Placing an asterisk before the name of the parameter after the “normal” parameters lets you do just that.’
How about: ‘Placing an asterisk before the name of a parameter after the “normal” parameters lets you do just that.’
(change ‘the’ to ‘a’)

(Dave says: I believe ‘the’ is correct)

Last paragraph ends with a double period..

In the first code example on this page, I am wondering: Is the splat argument being passed automatically in the call to ‘super’ without having to write the argument? This seems to be implied by the text right before the example. Or is it really not being used at all, as its name implies?

First sentence: “Earlier, we saw that if you put an asterisk in front of a formal parameter…”
It isn’t explained what a “formal” parameter is, but from the last sentence in this chapter, on page 139, it looks like it means a parameter in a method’s definition, as opposed to an argument in a call to the method. It might help to add a short statement to make this a little clearer.

Last paragraph: “Some languages feature keyword arguments — that is, instead of passing arguments in a given order and quantity, you pass the name of the argument with its value, in any order.”
How about “…you pass the name of EACH argument with its value…”

2nd paragraph: “…as long as they follow any normal argument and precede any array and block arguments.”
I think what is meant is: “…precede any SPLAT and block arguments.”

Last sentence: “…and teh value of the assignment as it’s last parameter.”
Should be “its”, not “it’s”

2nd paragraph: “It then returns that value as the result of the assignment expression.”
I think this would be much clearer if “that value” were changed to “that rvalue”.

“Users of older versions of Ruby should note that these rules have changed in Ruby 1.9.”
This sentence makes me wonder if the rules we are about to read are the new ones after the change, or the old ones before the change. I’m pretty sure it’s the former, but it could be a little clearer.

Under “Nested Assignments” header: “Ruby treats these terms as if they were a nested assignment statement.”
I don’t think this statement makes sense. I think it might make more sense if it were changed to something like: “Ruby treats these terms as if they were the left side of a nested assignment statement.”

Middle of page: ‘This is almost, but not quite, the same as var = var || “default value”. It differs in that no assignment is made at all if the variable is already set. In pseudo code, this might be written as var = “default value” unless var or as var || var = “default value”.’

I am left wondering: Is there any situation where this would have an effect. I’m having trouble thinking of one. And, this seems like the kind of thing that might end up compiling down to exactly the same machine instructions. Could this be clarified?

(Dave says: it’s subtle and we haven’t covered the ground we need to by this point.)

Last line: “descendents” should be “descendants”.

The definition in table 9.1 for === seems a little lacking, like it describes a common use for the operator, but not what it actually does.

(Dave says: seems the same as for the other operators—if anything it has more information :)

On this page: “if is an expression, not a statement—it returns a value.”
On the next page: “Statement modifiers let you tack conditional statements onto the end of a normal statement.”
And a little farther down: “Because if itself is an expression, you can get really obscure with statements such as” followed by an example of using a statement modifier on an if expression/statement.

I’m left a little confused about statements vs expressions. I would think that if is both a statement and an expression, contrary to what it says on this page (150). Could this language be clarified?

In example at top, change “#{input_line}” to “#{command}” to match the “case command” at the beginning of the example.

typo - should be your instead of you in 3rd paragraph from bottom

(If you subclass doesn’t need an initialize
method, then there’s no need to do anything

Last paragraph: “Ruby classes are instances of class Class, which defines === to test if the argument is an instance of the class or one of its superclasses.”

This sentence is confusing for a few reasons. Instead of “instance of the class”, how about “instance of the receiver”?
Also, it would make more sense to me if “or one of its superclasses” were changed to “or of one of its subclasses”.
(two changes here: “or” -> “or of” and “superclasses” -> “subclasses”)

2nd paragraph, last line: change “one through three and those between…” to “one through three as well as those between…”

Before last example: “only those lines that contain a d.” would be more correct if changed to “only those lines that end with a d.”

2nd paragraph: “redo repeats the loop from the start” would be a lot clearer if changed to “redo repeats the current iteration of the loop from the start”

Middle of page: “These keywords can also be used with any of the iterator-based looping mechanisms.”
I’m wondering if the meaning here is actually more general, and these keywords can be used any time in a block that is passed to a method and then run via yield or as a proc.

Or are we really just talking about “iterator-based looping mechanisms”? I can’t think of a way to distinguish in code between an “iterator-based looping mechanism” and some other use of a block.

Last paragraph: “A value may be passed to break and next. When used in conventional loops, it probably makes sense only to do this with break, where it sets the value returned by the loop. (Any value given to next is effectively lost.)”

I’m confused by this. Why is any value passed to next lost? If this is true, why is it possible to pass it a value at all? What if we’re in the last iteration through the loop? Couldn’t next finish things off, and potentially return its argument as the return value of the loop?

2nd-to-last paragraph: “that is exists” should be “that it exists”

Last sentence: should “the scoping of variables with blocks” be “the scoping of variables within blocks”?

“Do do this” should be “To do this”

The semicolon in “do |val; square|” should be a comma.

(Dave says: nope—see the end of the previous page…)

Footnote 1: “a descendent” should be “a descendant”. Also, this explanation seems to support my comment on page 152 about = and changing "superclasses" there to "subclasses". It's a clearer explanation of = than those on pages 152 and 150.

Top paragraph. This made me wonder, “if the second parameter is not supplied, does catch return nil?” After trying it, it looks like this is exactly what happens.

Wondering if an uncaught “throw” is basically equivalent to an unhandled exception? Are they treated the same way by Ruby, with different names to suggest different uses? (errors vs normal control flow)

(Dave says: an uncaught throw raises an exception. They aren’t the same)

After testing both examples that use file.each_line and substituting file.each, it looks like they do exactly the same thing. Wondering if there is a difference?

(Dave says: they’re the same method)

Curious about the differing behavior of << shown by the examples on this page, and by the following code:
string = “”
string << 99 << " red balloons\
" # => “c red balloons\
”
STDOUT << string
STDOUT << 99 << " red balloons\
"

1. >> c red balloons
2. >> 99 red balloons

/m at the end of a regular expression makes an appearance here. Looking it up, I see that it makes the dot match newlines. Might be worth a mention, though of course this section is not about regular expressions.

2nd paragraph: “…in reality Ruby’s fibers are really just…”
Sounds redundant. Maybe eliminate ‘really’?

(Dave basks in redundancy. Sometimes…)

Code sample: "resp = h.get(‘/’, nil )
The nil isn’t explained, and as it looks to be an optional parameter for a hash of headers with a default of nil, maybe it should be left out.

“Thread Variables” section, talking about “thread-local variables” sounded very similar to “local variables in the scope of the code running in a thread”. I was unsure if this was an entirely new namespace (eg, if in the example there would be a local variable to the thread named mycount).
On trying it out, it looks like these “thread-local variables” are indeed in their own separate namespace (the is no local mycount variable). It would make more intuitive sense to me if these were described more as keys in a Hash attached to a thread, and less as “local variables”.

Suggested change in footnote: for consistency, change “where the outcome changes” to “when the outcome changes”

3rd paragraph: “…an unhandled exception exception simply kills the current thread—all the rest continue to run.”
This is true unless it is the main thread that is terminated, right? In other words, the main thread is not “just another thread”?

Attempts to run these examples on my mac causes the following:
-:5: uninitialized constant Mutex (NameError)

Looks like adding “require ‘thread’” fixes it.

(Dave says: works on my Mac)

Looks like Will Bennett’s note about deadlock for page 173, examples 13 and 14, is talking about page 186 in this version.

Bottom example
Looks like “mutex.sleep 3600” should be “rate_mutex.sleep 3600”

(Wondering if mutex.sleep 3600 is the same as:
mutex.unlock
sleep 3600
mutex.lock

…or is it a little more than that?)

Start of “Running Multiple Processes” section
Suggested additional reason for running multiple processes: maybe you want code to run simultaneously on different processors or cores (since it was mentioned that Ruby threads don’t do this)

Last paragraph: “It returns false if the command was found, but returns an error when it runs. It raises an exception if the command cannot be found.”

How about: “It returns false if the command was found, but returned an error when it ran. It raises an exception if the command could not be found.”

I’m not sure what the “1.9” label next to the last paragraph on this page is referring to.

Wondering: in the examples on this page, how does Process.wait know which process to wait for? I assume it is waiting specificially for a child process of the current process to terminate? And if there are multiple child processes, will it be triggered by the first one to exit, whichever that may be?
In the second example, it looks like it retrieves some data on a child process after the child process has already exited (rather than, say, waiting for the next child process to exit).
Some more explanation of Process.wait could be helpful.

output from puts “child” doesn’t show up for the bottom example

3rd paragraph: “check the results are what you expected.”
How about: “check THAT the results are what you expected.”

2nd paragraph of “What is unit testing?” section:
“Fred may write the code with a bug one week…”
How about: “Fred may write code with a bug one week…”

Start of “Assertions == Expected Results” section:
“Test::Unit provides a series of assertions…”
How about changing “series” here to “set” or “variety”

In the example, I’m puzzled why ARGF.read is used as a sample of a method that returns nil( it didn’t when I tried it). Also, the message in the assertion, “Read next line of input”, would seem to make more sense if it described an error - something like, “read call shouldn’t return nil”.

2nd paragraph: “Test::Unit is clever enough to notice that there’s no main program, so it collects up all the test case classes and runs each in turn.
We haven’t been using any main(), such as C and Java have, so I assume ”main program" here means some other executable code?
If I add the line:
puts “Testing… (or not?)”
to a test case, and execute the file, it still runs the tests. So it doesn’t seem to depend on whether there’s a main program or not, unless I’m misunderstanding what a main program is.

5th paragraph: “It starts by working out the name of the directory from which the test file is run…”
I think this would be more correct if it said, “the location of the test file being run” (as opposed to the current working directory, which may be somewhere else entirely)

Bottom paragraph (as well as the example on the next page) suggests requiring test/unit in a test suite file. However, the next page goes on to say that there’s not much point in creating TestSuite objects. So the test suite file is just a list of statements requiring test cases.
Since the test cases will all require test/unit themselves, I don’t understand why requiring it in the test suite is recommended.

It seems like some other testing libraries, such as RSpec and Shoulda, are gaining significant popularity in the Ruby world. Maybe they’re worth a mention in this chapter?

in the list next to assert_instance_of and assert_kind_of, the first parameter is called ‘klass’. Wondering what this is?

In the sample debug session, the command is “l 1-9” but the output starts with “[1, 10]” (but still prints lines 1 through 9). When I tried it, I got an output of [1, 9].

3rd paragraph: “…you can use arrow keys (as with Emacs) or vi-style key bindings…”
How about something like, “you can use Emacs-style (including arrow keys) or vi-style key bindings…”

From the irb example, it looks like running a ruby program in irb starts a new thread, and not a new process. Wondering if this is the case?

2nd caption box: “take at look at all current jobs” should be “take a look at all current jobs”

Top example: comment has a funny ‘<<’ character rather than ordinary less-than signs.

In the benchmarking example, I’m wondering why the first run is a ‘rehersal’. Should it be considered less reliable than the second run, for some reason?

My problem may well be that I am still running 1.8.6, but I can’t see why c.say_hello would return two responses. In 1.8.6 at least, it only returns “Hello from #<Child:…>” as seems to be indicated in the text below.

Toward the end of the ARGV section: “make sure you empty the nonfilename arguments from the ARGV array before reading from the files.”

I’m curious if arguments that start with a dash are exempt from this.

Last paragraph: “I have my Ruby installed…”)
How about: “I have Ruby installed…”

Start of “RubyGems Integration”: “RubyGems system makes it easy…”
How about: “THE RubyGems sytem makes it easy…”

2nd paragraph: “You latest project…”
How about: “Your latest project…”

2nd paragraph: “let’s you construct” should be “lets you construct”

4th paragraph: “The -r option tells it to search the remote repository.”
Wondering if it should be “…to search remote repositories.” (is more than one possible?)

4th paragraph: “And -n option says…”
How about: “The -n option says…”

4th paragraph: “The result show…”
How about: “The result shows…”

Last paragraph: “First, we see that latest version…”
How about: “First, we see that THE latest version…”

Middle of page: “The most reliable way to find the documents is…”
How about: “The most reliable way to find the documentation is…”

End of page: ‘xml.preference( “ruby”)’
(minor formatting issue - extra space looks odd)

2nd paragraph: “the currently Builder” should be “the current Builder”

2nd paragraph: “15.2” should be “Table 15.2”

Wondering why “FileUtils::” prefix shows up in first code sample, but not in the second (for rm command)

(Dave says: because Rake provides rm)

3rd-to-last paragraph: “Our code uses it’s rm method. We use the Dir class…”
How about: “Our code uses ITS rm method. We use THE Dir class…”
(2 changes)

“Let’s package this is code as a task”
How about: “Let’s package this code as a task”

4th paragraph ends with “\\sd.”

End of 2nd-to-last paragraph: “Here’s for example, is a new task”
How about: “Here, for example, is a new task.”
(“Here’s” -> “Here,” and “.” at end)

2nd-to-last paragraph: “if your interested” should be “if you’re interested”

Sidebar is headed ‘require_relative and Ruby 1.8’, but the first sentence refers to Ruby 1.9 (‘In case you’re still running Ruby 1.9,’).

2nd paragraph: “The double colon (:: is…”
Missing closing paren

Footnote 2: “a class, such as String is really just…”
How about: “a class, such as String, is really just…”

Right under “Small Programs” header: “However, it you do this…”
How about: “However, IF you do this…”

2nd-to-last paragraph: “Here’s a single program…”
How about: “Here’s a simple program…”

Near end: “…and the last few lines look up each command line argument…”
How about: “…and the last few lines WHICH look up each command line argument…”

Near top: “effectivey” should be “effectively”

Near middle: “insode” should be “inside”

Near middle: “read you code” should be “read YOUR code”

Last paragraph: “It’s job” should be “Its job”

The new 1.9 require_relative feature discussed on page 238 should be mentioned here in the discussion about adding paths in tests to the files being tested!

(Dave says: I’ve rewritten that section)

Output on this page shows an error.
Shoulda installed Shoulda!
(This also happens on page 240)

For sample file 10, it looks like we’ve skipped 7, 8 and 9 in the numbering

The example starting on the bottom of this page should be for the TestFinder class. Instead, it shows the TestOptions class, which we already saw on pages 237-238.

Error loading shoulda (also on page 238)

Sample files 13 and 14 - did we skip 12?

Sample file 13:
#! /usr/local/rubybook/bin/ruby

How about:
#!/usr/bin/env ruby

2nd paragraph: “Now all our files are in place.”
…but we never wrote a test for the Runner class

Running sample project shows error (undefined method `require_relative’)

2nd-to-last paragraph:
“So we’re really looking for a way to take our little application and install it in a standard way.”

How about:
“So we’re really looking for a standard way to take our little application and install it.”

Last paragraph: “If puts its libraries” should be “It puts its libraries”

Near top: “…downloaded archive on [url]…”
How about: “…downloaded archive AT [url]…”

2nd-to-last paragraph, we see both “Gems are also a great way…” and “Gems is the way to go.”
Should the second be “Gems ARE the way to go.”

Last paragraph, we see both “…is to use rake” and “Using Rake…”
Should the former be capitalized?

(Dave says: the first use is the command)

A little below middle of page:
“The s.executables line tells Gems to install anagram command-line script the Gem gets installed on a user’s machine.”

How about: “The s.executables line tells Gems to install THE anagram command-line script WHEN the Gem gets installed on a user’s machine.”

Bottom: “/Users/dave//code/anagram” has a double slash

Looks like the gem server being discussed is an http server. I’m curious what this does that an ordinary http server doesn’t do (probably something to do with the info you get when listing directories?)
Also, would/do gem commands work if you put a gem file on an ordinary http server instead? If so, what’s the difference in what you can do versus hosting on a gem server?

Near bottom: “This is particular useful”
Should be: “This is particularly useful”

GitHub is very popular now too, and offers gem hosting. Worth a mention here next to RubyForge?

In 2nd paragraph we see both, “a rich set of Rake tasks” and “a number of rake tasks”
Looks like inconsistent capitalization

2nd paragraph: “RUbyForge” should be “RubyForge”

Last paragraph: “…while other prefer…” should be “…while others prefer…”

3rd paragraph: “In addition, many encodings have aliases…”

I’m wondering if you can ask an Encoding object to list its aliases. (There’s a “MISSING: Aliases” tag - not sure if it’s related to that)

Right before “What Has Encodings” section: “For UTF-8.” is a sentence by itself that looks like a mistake.

Last paragraph: “However, unlike Ruby 1.8, If any…”
Don’t think “If” should be capitalized

Bottom paragraph: “These examples illustrates…”
How about: “These examples illustrate…”

2nd paragraph: “If you do, Ruby interprets all characters with codes below 128 as regular ASCII, and all other characters as valid constituents of variable names. This is basically a neat hack, as it allows you to compile a file written in an encoding you don’t know—the characters with the high-order bit set will be assumed to be printable.”

Since this paragraph is talking about binary data, it would make more sense to me if “characters” was replaced with “bytes” throughout.

Bottom: ‘…either an “coding:” comment…’
How about: ‘…either a “coding:” comment…’

Paragraph near bottom: I’m curious - if a file has both a UTF-8 BOM and a “coding:” comment (that says something other than utf-8) will this cause an error? Or will one take precedence over the other?

Middle paragraph: “…what encoding to use on literal strings and regular expressions”
How about something like: “…what encoding to associate with literal strings and regular expressions”

Middle paragraph: “…literal strings and regular expressions.”
How about: “…literal strings and regular expressions (if they have a top bit set).”

Bottom: “Here we fake that out by creating a ASCII-8BIT string that contains a ISO-8859-1 sequence”
How about: “Here we fake that out by creating an ASCII-8BIT string that contains an ISO-8859-1 sequence”
(would seem to match earlier usage)

Last two paragraphs

First begins: “Because of this, you cannot use encode to convert a sequence of bytes held in an ASCII-8BIT tagged string to some other encoding.”

Second begins: “Finally, you can use encode to convert between two encodings if your source string is ASCII-8BIT.”

It goes on to say we do this by passing a second parameter, but the two sentences above directly contradict one another. This could probably be worded more clearly.

In table 18.1 for “—inspect, —noinspect”:
“Use/don’t use Object#inspect to format output (the default, unless in math mode).”

It is not clear here which of these is the default.

In table 18.1 for “-r load-module”:
Same as ruby -r.

It would be more helpful to say something like:
Same as ruby -r. Like running “require ‘load-module’”.

(Or is it more like running “load ‘load-module’”? Or is there even a difference in this case?)

Last sentence: “Variables you set, methods you define, and classes you create are all remembered and may be used subsequently.”

How about adding a parenthetical “(while in the same session)” to the end

End of “Tab Completion” section talks about needing to load irb/completion library to enable tab completion. On my machine (a mac) this appears to be enabled by default. Maybe it’s different for the standard ruby distribution, but in case it isn’t, I’m noting that I didn’t have to do anything to use tab completion.

3rd paragraph: “For example, to make SIMPLE the default prompt for all your irb sessions…”
How about: “For example, to make SIMPLE the default prompt mode for all your irb sessions…”

Top: “Because the things you type to irb…”
How about: “Because the things you type into irb…”

First example:
I’m getting errors when trying to run “block.()” (should this be “block.call()”?

…and the line “time 1000000.times ”cat“.upcase”
(but it works when I add braces to get: “time {1000000.times {”cat“.upcase}}”

(referring to the timing example)
“The next time you start irb, you’ll be able to use this method to get documentation.”

How about something like “…to get benchmarks.” instead

Bottom: “Displays lines n initial and n final lines of backtrace.”
How about: “Displays n initial lines and n final lines of backtrace.”

:MATH_MODE description
“If true, irb runs with the mathn library loaded”

…but loading the mathn library isn’t the same as turning on math mode, is it? There seem to be other things that are different when in math mode.

irb_change_binding description:
“If obj is given, it will be used as self in the new binding.”

I’m confused about the case of not passing in a value for obj. When I try this, it doesn’t seem to do anything at all (the same variables that were in scope before are still in scope). Also wondering if self would be nil in this scenario.

(Dave says: if you don;t pass a value, self is unchanged)

In the definition for the default prompt mode, should the return line (:RETURN => “%s\
”) instead say (:RETURN => “=> %s\
”)?

Why isn’t :SAVE_HISTORY in th list on page 267?

2nd paragraph: “…some HTML format RDoc output…”
How about: “…some HTML formatted RDoc output…”

Caption for Figure 19.2, 4th line: “…and in the command for the new method…”
should be: “…and in the COMMENT for the new method…”

Wondering why tags rather than

End of 2nd paragraph: “stops it being interpreted.”
how about: “stops it FROM being interpreted.”

Last paragraph: “to stop a comment being associated”
how about: “to stop a comment FROM being associated”

Last paragraph: “method, class, or module.”
How about: “method, class, attribute, or module.”

In Figure 19.4, the line “return Proc.new |n| n*factor” fails on my setup unless I add braces (“return Proc.new {|n| n*factor}”

Bottom: “Both the following are…”
How about: “Both of the following are…”

Description of :nodoc:
This paragraph is awkward. It first says that methods inside a class or module will be omitted, then says that by default, they won’t, and then says that with a modifier, they will. Could be reworded.

(Dave says: It says that modules and classes won’t be omitted, not methods.)

Description of :doc:
Could add, " or a method below a ‘:nodoc: all’" (if indeed this is true)

Description of :title:
Wondering, what’s the title if there’s no :title: directive and no —title command-line parameter. Is there one?

Description for :stopdoc: / :startdoc:
“If you don’t specify a :startdoc: by the end of the container, disables documentation for the entire class or module.”

Should this be, “…for the REST OF THE class or module.”?

Near start of “Adding RDoc to C Extensions”:
“Most C extensions hav an Init_Classname function. RDoc takes this as the class definition— any C comment before the Init_ method will be used as the class’s documentation.”

How about changing “Init_ method” to “Init_ function” to match the earlier usage.

call-seq used twice in the last paragraph on pg 281 and once on page 283 without colons. Other directives have colons by their names.

Halfway down source in Figure 19.5:
Comments have “Fibonacci.upto(count)” but that was for the method above. This method uses ‘max’, not ‘count’.

Halfway down source listing in Figure 19.5:
Block version of call sequence is missing a closing pipe character.

2nd paragraph: “Although RDoc heuristics work well for finding the class and method comments for simple extensions, it doesn’t…”

“it doesn’t” should be “they don’t”

3rd paragraph: “Finally, it is possible in the Init_ method…”
How about: “Finally, it is possible in the Init function…”

At end of Figure 19.6, there is a blank line between the last method and its comment. Wondering if this matters to RDoc?

4th paragraph: “Files ending .c are…”
How about: “Filenames ending .c are…” (matching usage in the preceding sentence)

4th paragraph: “If directory names are passed to RDoc, they are scanned recursively for C and Ruby source files only.”

The footnote on page 273 mentions Fortran 77 programs, but Fortran isn’t mentioned here at all…

5th paragraph:
Wondering, if a subdirectory is omitted from a .document file, will it (and all its descendants) be skipped?

Near bottom: “You may find it convenient to write this file in Rdoc format, and then use the :include: directive to incorporate this document into that for the main class.”

How about: “…into the documentation for the main class.”

Near middle: “To add documentation to ri, you need to tell RDoc which output directory to use. For your own use, it’s easiest to use the —ri option.”

How about something like, "…For your own use, it’s easiest to use the —ri option, which installs the documentation into ~/.rdoc/.

First paragraph below sidebar: “…extract it straight from the command and write it to the user.”
Should be: “…extract it straight from the COMMENT and write it to the user.”

“…with the RI option set to…”
How about:
“…with the RI environment variable set to…”

2nd-to-last paragraph:
Consider removing parens around last sentence. After all, this sentence introduces the example that immediately follows the paragraph.

“To get really fancy, you can decide to escape only certain HTML elements within a string.” (followed by example)

I wondered, “How do you add more elements to the list to escape?” By trial and error, it looks like additional parameters, each with a string containig a tag name, does the trick. Noting it here in case it’s deemed worth mentioning.

Top: “…the required level of HTML…”

How about: “…the required version of HTML…”

cgi example:
Wondering, why braces? Didn’t the book say the convention is to use do…end when a block spans multiple lines?

Amrita example:
Wondering why the top-level tag is

rather than

(Dave says: ’cos that’s all I’m demoing… :)

Middle of page, describing erb command:
“If the document is omitted, eruby will read from standard input.”
Change “eruby” to “erb”

2nd-to-last paragraph has several mistakes:
“The lines starting with the percent sign simply execute the given Ruby In this case, it’s a loop that iterates the line between them, setting The next line contains the sequence <%= number %>, which substitutes in the value of number into the output.”

How about something like: “The lines starting with the percent sign simply execute the given Ruby statements. In this case, it’s a loop that iterates over the line between them, setting the number parameter each time. The middle line contains the sequence <%= number %>, which substitutes the value of number into the output.”

2nd paragraph: “you can’t use the -%> trick to suppress blank lines.”
How about “newlines” instead of “blank lines”?

Top paragraph briefly discusses bindings. I’m wondering what is in a Binding object. A hash of the variables? If this isn’t the place to go into that, maybe add a link to the place that is?

“Cookies” section:
text says, “…by setting the cookies parameter…”
last line of code: “cgi.out(”cookie" => cookie ) {msg}

‘cookies’ or ‘cookie’?

Start of “Sessions” section:
“We really want session: information that persists…”
How about: “We really want SESSIONS: information that persists…”

2nd-to-last paragraph: “The filenames will all start web-session. and will end with a hashed version of the session number.”
How about: “The filenames will all start WITH web-session. and will end with a hashed version of the session KEY.”
(Or are ‘session number’ and ‘session_key’ actually two different things here? I didn’t see any other reference to a session number.)

Last paragraph: “plug in-based”
How about: “plugin-based”?

2nd paragraph: “Web” is capitalized (but in the first paragraph, it isn’t)

2nd paragraph: “run your applicate”
How about: “run your application”

2nd-to-last paragraph: “Merb as a lighter-weight alternative to Rails.”
How about: “Merb IS a lighter-weight alternative to Rails.”

Last paragraph: “Alternative frameworks include…”
How about: “Other alternative frameworks include…”
(Merb was already mentioned)

Last paragraph: “By the time your read this…”
How about: “By the time YOU read this…”

2nd paragraph: “For example, I download the .zip file”
How about: “For example, I DOWNLOADED the .zip file”

In the sample shell commands, the command setting the PATH appears twice for some reason, and we cd to \\ruby19, which we’re already in

4th paragraph: “..generates a PDF file, which the Ruby script downloads into a local file.”
How about “…into a local DIRECTORY.”

2nd-to-last paragraph: “An OLE object’s parameters are automatically set up as attributes of the WIN32OLE object. This means you can set a parameter by assigning to an object attribute.”

I think the two occurrences of “parameter(s)” here should say “propert(y/ies)”.

Last paragraph: “…the sample file excel2.rb”
Is this supposed to refer to one of the samples directly above here, win32_4.rb or win32_5.rb?

(Dave says: it refers to the file in the code download)

2nd paragraph under “More Help” heading:
“For example, the following code, taken from the DL source code in the standard Ruby distribution, pops up a message box on a Windows machine, and determines which button the user clicked.”

Consider elimating the last comma (after “Windows machine”)

Last paragraph: “THis” should be “This”

Last paragraph: “…what Rails does with its .erb/html templates.”

I think “.erb/html” should be “.erb.html”

The examples of inject at the top of the page do not work.

(Dave says: The example output is generated by executing code every time the book is formatted…

Maybe you’re using Ruby 1.8?)

You might want to mention somewhere that the posix character classes require double brackets to work: [[:print:]] or at least I think they do. Some examples of using these would be nice.

Also, a more clear definition of “graph”, “printable”, etc as they apply to Ruby strings.

Sorry, I see the examples on page 122 of posix, but still having trouble with it. I think maybe [:ascii:] and [:word:] aren’t supported in 1.8.6

Invalid regular expression; [:ascii:] is not a character class: /[[:ascii:]]+/
invalid regular expression; [:word:] is not a character class: /[[:word:]]+/

(Dave says: No - I think these are 1.9 features)

code illustrating “shebang” includes puts “Hello, world!”, but the output shown is "It is now…….

may be confusing to new folk

Second half of page says: And -n option … whose name matches the regular expression /builder/.
The example above searches for ‘build’, not ‘builder’. So either example or description should be corrected.

The Header is “Reading and Writing File” but the example only shows reading and there is actually no example of File writing

That’s a higher-level heading. The second on writing is contained with in.

Word missing in first paragraph after “Anyone for Shoulda?”:
You [word missing] much of the descriptive power of RSpec-style expectations without having to commit to the
full framework.

“Should” should be “Shoulda” in second paragraph under “Anyone for Shoulda?”:
Install Should[a] using gem install Shoulda.

In the first full paragraph on the page, fourth sentence, unlike LIFE not like.

Integer(price * 100)
Price = 33.8
Price in cents = 3379

To me this just seems wrong. If I am a store owner I would loosing money here… I am sure there is a perfectly fine explanation for this and I think here would be a good place to explain it or at least a foot note detailing where it gets explained. I suspect it is a rounding issue but it does not seem right to me.

Near bottom: duplicate duplicate “that that”

Footnote 6: Should “conventially” be “conventionally”?

Middle paragraph: “…and a block parameter (arguments starting with an ampersand).”
Should “arguments” be plural or singular here?

Toward end: “Arrays, support this:”
Should this be, “Arrays support this:” (without the comma)?

Paragraph in middle of page: “they typically make most sense when…”
How about: “they typically make THE most sense when…”

Last paragraph: “The === operator is defined in Class to test if the argument is an instance of the receiver or one of its superclasses.”

There seems to be a little ambiguity over whether the last part of this means
“…or if the argument is an instance of one of [the receiver’s] superclasses”
or
“…or if the argument is one of [the receiver’s] superclasses”

3rd paragraph: “you can even mix Shoulda tests for regular test::Unit test methods.”
How about: “you can even mix Shoulda tests into regular test::Unit test methods.”

Near bottom: “[1, 9 in t.rb”
Looks like it’s missing a closing bracket…

Footnote 3: “We talk about Shoulda starting on page ??. For now, you can run this code by installing the gem using gem install Shoulda.”

I don’t know if there’s more on it later in the book (since this footnote was also in the previous version), but Shoulda is now introduced in this version before we get here, and has what looks like it might be the start of a section on page 208.

Top of “require_relative and Ruby 1.8” sidebar: “you can use still use” (extra ‘use’ in there)

“Now all our files are in place, we can…”
How about:
“Now THAT all our files are in place, we can…”

4th-to-last paragraph: “The s.executables line tells Gems to install the anagram command-line script the Gem gets installed on a user’s machine.”
How about:
“The s.executables line tells Gems to install the anagram command-line script WHEN the Gem gets installed on a user’s machine.”

Near end of “Source Files” section: “For UTF-8. If Ruby sees the byte sequence…”
I’m guessing this should be a comma after “For UTF-8”?

First paragraph: “…as if the template is eing evaluated…”
Change “eing” to “being”

in frozen?
“or it it is in” should be “or if it is in”

“so I;d recommend a quick web search rather.. ”
should be “so I’d recommend a quick web search rather..”

“HEre we can just use rm”
should be “Here we can just use rm”

“.. options.rb file inslde a directory named anagram..”
should be “.. options.rb file inside a directory named anagram”

In the first line, it should be ‘user stories’ instead of ‘user stores’

“Tama” sounds strange to me for a Japanese female name, but for a Japanese cat’s name. Mai, Hana, Yui are much better… I dont know…

If has a
few incompatibilities with the original.

should read:

It has a
few incompatibilities with the original.

The description for CGI.escapeElement says; “Here only the A element is escaped; other elements are left alone.” but

element is also escaped.

In the first sentence on page 534 there is a double ‘an’:

“Modes can be represented an an integer formed by or-ing together values from Table…”.

Perhaps “Modes can be represented by an integer…” is what you want?

Great book. I am thoroughly enjoying it.

Description of each_byte needs to be separated into two lines. Line reads:
“io.each_byte {| byte | block } →nilio.each_byte → enum” but should be

“io.each_byte {| byte | block } →nil
io.each_byte → enum”

In the IO#gets section, you have this sentence:(although the setting of $_ is considered ugly, an may be removed in future). The word “an” is probably meant to be “and”.

(for example, by invoking items.size, the process is surprisingly similar.
should be
(for example, by invoking items.size), the process is surprisingly similar.

Appear to be missing ‘sort’ (have ‘sort!), and ’sort_by’ methods.

(Dave says: sort is defined in Enumerable)

‘each_with_index’ overlaps the description (at least in the pdf).

sample code uses attr_reader for defining an accessor method. But I feel that using instance_variable_get method is appropriate in this context.

(Dave says: I don’t agree here. I wouldn’t use instance_variable_get in regular code to define an attribute reader, so I don’t think I’d do it here, either)

“The ony change—and it’s a vitally important one” should say “The only change—and it’s a vitally important one”

In 1.8, ‘members’ returns an array of strings rather than an array of symbols. Does this change in 1.9?

‘tuples may be matched using regular expressions, the classes of their elements,’ s/b ‘…expressions, or …’

title of “instance_eval and class_eval” on the side panel is linked to page 398, not 397.

When you define a class method in the block of class_eval for MyClass
, it become a class method of MyClass. When you define an instance method in the block of instance_eval for an instance, it become an instance method(singleton method). so, paragraph in middle of page is confusing for me.

When describing the ‘|’ character in the regular expression /Perl|Python/, you refer to it as a “pipe character”. “Pipe” describes the character’s use in Unix shell commands (later copied, sort of, in the DOS command line), but doesn’t really properly identify the glyph. Two pages later you refer to the character as a “vertical bar”, describing the syntax for passing parameters to yield blocks; and the Windows Character Map accessory refers to it as a “vertical line”. Either of these two designations is preferable to “pipe”, in my opinion. I’m feeling too lazy right now to track down the official name(s) of this character in the ASCII and Unicode specifications, but I’m quite sure it’s not “pipe”.

“you application will silently ignore calls to unknown methods in your class.”
should be
“your application will silently ignore calls to unknown methods in your class.”

“The OpenStructclass is distributed with Ruby.”
should be
“The OpenStruct class is distributed with Ruby.”

The code on 66-67 does not work. Error line 11 Csv_reader.

(Dave says: the output in the book is produced by running that code at the time the book is formatted. Do you perhaps need to update your Ruby installation?)

If you explain about MY_CLASS constant in your code, it would be helpful.

(Dave says: actually, the implementation was faulty—I’ve fixed it, and MY_CLASS is no more…)

“define_method—it’s defined in class Object.”
should be
“define_method—it’s defined in class Module.”

> Returns the regexp object for the regular expression that cerated match.

s/cerated/created

> Returns true if obj lines between the start and end of the range.

s/lines/lies

> Then, as you fill in the code, the specs mutate into tests that validate your code meets your expectations.

Revise ‘meets your expectations.’ Pehaps ‘which meets your expectations.’

how about adding following codes?
p Example.methods(false)
p Example.instance_methods(false)

See how the code in the block (puts “In the block”) is executed twice, once for each call to
yield.

should be:

See how the code in the block (puts “In the block”) is executed twice, once for each call to
yield?

The period should be a question mark.

For the really beginers perhaps you should mention how to quit from irb and go back to the command prompt.

The description of the example at the top of the page references “Line 11” but the example code doesn’t have any line numbers listed. It would be helpful if the code was shown with line numbers.

The title of the section is Reading/Writing to Files but I don’t see any examples for writing to files? I see it for reading only.

(Dave says: writing is discussed starting on page 173)

The example at the bottom of the page does not make sense. It looks like you are trying to make a point about blocks but the examples are the same as your output proves. Yield produces ‘three’.

(Dave says: look carefully at the output…)

In the BookInStock class definition on page 57, you convert the price to a floating point number using Float(price). However, the reader is left guessing what this type-conversion does exactly and, more importantly, why you don’t do something like price.to_f and how/why that differs from Float(price). If there is no difference, what is the best practice, and why are there two ways of achieving the same results. (This is something that annoys me in general about Ruby: often the same thing can be achieved in many different ways and it is not always clear why or which alternative should be preferred. If a book like this could shed more light on that, that would be welcome.)

(Dave says: at the top of the page it says: The Float method takes its argu-
ment and converts it to a floating point number,1 terminating the program with an error
if that conversion fails. I don;t want to go into any more detail than that here. There’s no real best practice: to_f and Float do different things, and the choice is contextual)

Again this is an example how the same thing can be done in Ruby in many different ways. Either you define accessor methods yourself, or you use the shorthand notation. It is good that the book mentions both possibility, but I suggest adding what the “preferred” policy is. Is it best-practice to always use the shorthand notation? The book doesn’t explicitly state this.

(Dave says: there’s no real best policy, but why type out a long method defiition when a single line will do?)

In the example (tutclasses_14.rb) on this page you use the expression
Integer(price * 100)
The reader may wonder what the difference is with
(price * 100).to_i
and which of the two solutions should be preferred.

Again, as with so many things in Ruby, two different ways of achieving the same thing. In this case: specifying access control. I suggest that, in addition to explaining the two alternative ways of specifying access cotrol, you give the reader a hint on what the preferred way is (or what you prefered way is) and under what circonstances what alternative should be used.

In Figure 5.1, why is the notation with three dots, for example a[1…3] not illustrated, although it is explained in the text on the previous page. I would suggest adding it to the figure too.

Description of Integer::even?
“Returns true is int is even.” should be
“Returns true if int is even.”

“Exist an irb session by typing exit,” should be
“Exit an irb session by typing exit,”

In the section “Writing to Files”, you don’t actually have an example of writing to a file. You skip right to writing binary data, using <<, and then to the next section, Doing I/O with String.

Description of Array#pop could be read to say that pop is new in Ruby 1.9. Should be rewritten somehow to make it clear that pop exists in 1.8, and that only the optional numeric argument is new in 1.9.

Second paragraph begins:

“A better solution is to assume that your Ruby program is packaged according to the conventions we’ll be discussion in Section 16 on page 245. In this arrangement…”

with the typo occurring at “according to the conventions we’ll be discussion”

In footnote 1, “the objects class hierarchy” should be “the object’s class hierarchy”

“The call to Test.new on line 11” should be “The call to Test.new on line 10”

“When you include a module class Example,” should be “When you include a module IN class Example,”

`gem install Shoulda` is no longer supported. Instead, please update the instructions for a shoulda install to read:

sudo gem install thoughtbot-shoulda —source=[http gems.github.com]
OR

gem sources -a [http gems.github.com]
sudo gem install thoughtbot-shoulda

I’m trying to convince Tammer to dual publish the gem to rubyforge also, but no luck so far ;-)

NOTE: Substitute the github gem url above for the correct one. This wouldn’t let me submit with embedded URLs.

Prose description of each_with_object, besides missing the initial ‘C’ in ‘Calls’, makes no sense, compared with the example code. Prose appears to be an alternate description of each_with_index.

The description of Enumerable.inject taking an operator and operating successively on the first two elements, etc., is not correct for Ruby 1.8. This example should have a big “1.9” around it.

(Dave says: that would be very confusing, as it would look like the 1.9 part was referring to the text. This whole book is for Ruby 1.9, so the flagging of changes is more a courtesy to the reader)

In the sentence, “First, all the rvalues are evaluated, left to right, and collected into an array (unless thay are
already an array),” ‘thay’ should be ‘they’.

The special-case description of Array.insert(–1, obj) is confusing and unnecessary, making it seem as if –1 behaves differently from other negative indexes. The behavior where index == –1 is consistent with any other negative index.

Suggested text:

If index is not negative, inserts the given values before the element with the given index.
If index is negative, inserts the values after the element with the given index.

If you want to call particular attention to the behavior with –1, I suggest adding text after the “if negative” sentence, perhaps parenthetically. Something like "This means that if index is –1, the given values are appended to the end of the array, making array.insert(–1, obj) equivalent to array.push(obj):

Description of []= says,

“(Prior to Ruby 1.9, assigning nil deleted the corresponding array elements; now it simply assigns nil
to them.)”

but, at least in Ruby 1.8.6, it’s not as simple as this.
Some very brief testing shows that the behavior depends on the form of the assignment
array[int] = nil
does, in fact, assign nil to that element
array[start, length] = nil
and
array[range] = nill
do delete the corresponding elements.

“Equivalent” code for slice! is not actually equivalent.
Pre 1.9, if args is a single integer argument, then
self[*args] = nil
does not delete anything from the array, and according to the book (I don’t have 1.9, so can’t verify this), in 1.9 all argument forms will result in this expression assigning a nil to part of the array.

Description of merge! omits description of the second form. It’s clear from the code examples that merge! behaves exactly as merge , but operates directly on hsh instead of on a duplicate.

The description of rb_protect says: “Executes body with the given args and returns nonzero in result if any exception was raised. The value in state corresponds to the various TAG_xxx macros.” (emphasis mine)

However, the declaration of rb_protect in the book doesn’t have a “state” parameter; I’d suggest changing the third parameter (currently “result”) in the declaration to “state” to match the description of the function and the implementation of it in eval.c.

The text contains the following lines:

“We also said that all Ruby objects know how to handle to_s. But we’ve also written our own classes that don’t implement to_s. But we didn’t say how.”

The intent here is to say that our objects don’t explicitly define to_s, but handle it anyway. The above text is not clear.

“enum.choice( n=1 ) → an_array or nil” did not get updated to reflect the new method name (“sample”).

reads:
“Matches zero of more directories”
“Matches zero or more directories” — “or” not “of” ?

This seems wrong if a thread has been killed:

Thread.kill(a) # => #
…
a.alive? # => true

(Dave says: I added a sleep to give it time to die)

“For example, we might be wring a simple DSL” should be
“For example, we might be writing a simple DSL”

“To draw … 5x5 squares, we might write:
…
4.times do
forward(4)
left
end”

It seems to me very unlikely that we would be writing “forward(4)” to draw a side of a 5x5 square. To avoid confusion, I suggest either changing “5x5” to “4x4”, or (probably better, to prevent confusion between different uses of the number 4) change “forward(4)” to “forward(5)”

dave[RUBY3/Book 18:21:04*] ruby code/classes/turtle.rb 
#####   #####   #####
#   #   #   #   #   #
#   #   #   #   #   #
#   #   #   #   #   #
#####   #####   #####

It would be useful to have all hierarchies of the TOC in the PDF-TOC as well (for ease of navigation).

" Previously is was impossible to pass a local or.."
should be
" Previously it was impossible to pass a local or.."

In Turtle class, “def walk(…) end” should be “def walk(…); end”.

(Dave says: actually, you don’t need the semicolon if there’s a parameter list, but I added it for consistency)

The example code for String#match is either poorly considered or poorly typeset: it is almost impossible to determine the difference between the lower-case “L” characters and the digit “1” in the regex expressions.

Those with prior experience with regular expressions will know what’s what - but that’s not the point.

It wouldn’t be particularly difficult to choose a different example…use ‘greetings’ instead of ‘hello’ and match on the ‘ee’ instead.

For the code sample “tutclasses_6.rb”, the 3rd books pricing is in speech marks, whereas the previous two books prices are not in speech marks.

Confusing to have Table 15.2’s description “Both the gem…” cut into the middle of the sentence “rake is an automation tool”.

Closing brace is missed in the phrase “(The $end in the message means end-of-file, so the message simply means that Ruby hit the end of your code before finding all the end keywords it was expecting.”

Some markup in the middle of the page was not processed by the PDF generation engine: “% ruby -I \\emph{path/to/app} \\emph{path/to/app}/test/test_roman.rb”

Hello Dave,

When describing Module.instance_methods you explain: “Returns an array containing the names of public instance methods in the receiver.” It would be beneficial to point out _explicitly that this includes protected methods as well. I was just rereading and had to test it. :) A small note would have saved me some time.

wee% cat im.rb
module M
def pub; end

def pri; end

def pro; end

public :pub
protected :pro
private :pri
end

p M.instance_methods
wee% ruby -vw ./im.rb
ruby 1.8.7 (2008-08-11 patchlevel 72) [powerpc-darwin9.5.0]
[“pro”, “pub”]

For the PDF version, please include a clickable A-Z list for the Index, as is done in the Rails PDF. I’m not sure what the proper PDF terminology for this is, but in the Preview app on Mac OS, it appears in the sidebar as an outline. The Rails PDF has “Symbols” and “A” through “Z” under “Index,” whereas the Ruby PDF does not. It’s very convenient. Thanks.

(Dave says: your mere wish is my command. I didn’t bother creating a new release, but regenerate your existing PDF and the subentries will appear.)

Struct::new has two different 1.9 indicators, but as near as I can tell, it’s behavior is unchanged from Ruby 1.8. The block trick has been poorly documented in the past, but I’m pretty sure it’s been there for quite a while (1.8.4 or so maybe). It’s definitely in 1.8.6:

Name = Struct.new(:first, :last) do
def full
“#{first} #{last}”.strip
end
end

p RUBY_VERSION
p Name.new(“James”, “Gray”).full

1. >> “1.8.6”
2. >> “James Gray”

(Dave says: the first is indeed incorrect. The second flag is correct, though. In 1.8, #members returned strings, and in 1.9 symbols)

The second bullet point of the CSV description sounds like broken English, though I guess it is technically OK:

“Some CSV files have a header line. Read it, and then process the rest of the file. Auto-matically convert fields that look like numbers.”

I think a little rewording would help there.

Also you are missing some fun of CSV tables on the next page. Try adding these lines to you examples:

p table[:count]
table[:in_stock] = [10, 5, 10, 10]

The thread.exclusive section is mislabeled as ‘pass’.

YAML.dump produces;

—- !ruby/object:Special
precious: World
valuable: Hello
volatile: there

(Dave says: not if you define to_yaml_properties)

The documentation for tmpdir doesn’t cover the new Dir.mktmpdir method.

“ynonym for each_with_object.”
should be
“Synonym for each_with_object.”

“alls block with two arguments,…” for each_with_object
should be
“Calls block with two arguments,…”

1.9 symbol is out of alignment.

You are missing coverage for some nice additions to the shellwords library:

• shellsplit() is added as an alias for shellwords()
• shellescape() was added to escape a String for use in Bash
• shelljoin() was added to escape and join an Array of arguments
• shellsplit() and shellescape() are added to String and shelljoin() is added to Array for easier access

Access Control section says, “Private methods therefore can be called only in the defining class and by direct descendents within the same object.” This does not follow from the definition of private methods, and is not true.
Example:

class Parent
def parent_meth
puts “Calling child’s private method”
child_private
end
end

class Child < Parent
private
def child_private
puts “This is the child’s private method”
end
end

child = Child.new
child.parent_meth

####End of example

Even though child_private is being called BY a member of the class within which it’s a private method, it’s being called WITHIN the parent class, not in the defining class or by any descendants. In a sense, Parent here resembles an abstract class in Java, in that it expects (if parent_meth is called) that its child classes will define child_private.

And, of course, this example could be extended to any level of ancestry, with Parent being a grandparent, etc., of Child.

(Same error applies to Programming Ruby, 2nd edition)

Under “#” in the index, please add an entry pointing to the preface where you explain the Classname#methodname notation that you use. I remember when I was reading the previous edition, I kept running across this in the text but couldn’t find the explanation of whether this was a legal Ruby method name or what. I only figured it out when I ran across almost by accident when looking at the preface some time later.

Error on all Pages…….

On the Footer the “Prepared by …” and the Report Erratum" are overlapping..

Note in the Array#pack method references String#unpack on page 699. The actual page is 701 and the link sends you to page 689.

For the Array Class, the “first” method is defined on page 454 but not described in the following ones (which may be 461).

Hope It Helps ;)

(Dave says: #first is not a method of Array—-it is mixed in from enumerable)

“MISSING: MacPorts doesn’t yet have 1.9. Check comment before going to print”

It does - not sure when that changed, but the version I have installed was built in July apparently:
$ sudo -s

1. port list | grep ruby
2. port list | grep ruby | grep “1.9.0”
   ruby19 @1.9.0-3 lang/ruby19
3. port install ruby19
   …
4. /opt/local/bin/ruby
   ruby 1.9.0 (2008-07-25 revision 18217) [i686-darwin9]

It’s not as recent as building from source, but that’s somewhat expected for MacPorts.

class variables will are private

“You can ask it to compile the Ruy code” should be “… Ruby code”

“Maybe you want to know you Ruby…” should be “Maybe you want to know how Ruby…”

“The two character sequence ”\\xcf\\x80" represents pi in UTF-8, but is not a valid byte sequence…" should be “The two byte sequence…” (In a chapter about character encodings, it’s important to pedantic around the usage of “bytes” and “characters”.)

“Get out their and match some strings.”.sub(/their/, “there”)

Footnote 2:
“When we multiple 33.8 times 100”.sub(/multiple/, multiply)

The method “price_in_cents” uses “price”, not “price" (inconsistent with the other uses). I both work, but I presume "price” is a better choice. On the other hand, I’m a Rube, so I could be wrong.

def price_in_cents
Integer(price*100 + 0.5)
end

(Dave says: I prefer using the accessor method: it decouples the code better)

TIme should read Time.

Context: (Note that the second string contains the text TIme.now between curly braces, and not paren-
theses.)

at the start of this page, \\d should be \\w.

a.sample(6) should be something like [“a”, “d”, “c”, “b”]

at the bottom of page, the description of max_by would be enum.max_by {|item| block } -> obj or enumerator

At the start of description for `try_convert’, it would be `If obj is not already an io object, …’

In the description of close_on_exec?, it would be `… close on exec …‘, not `esxec’

In the description of `getbyte’, it might be `8-bit byte’

samples/packaging_14.rb class Runner, def run: if no anagrams found, output line should puts “No anagrams in #{word} in #{@options.dictionary}” - missing the @options receiver

Under String#chars:

< See also CIMString.bytes.
> See also String.bytes.

The documentation for each_with_object is unclear. Where is ‘block’ in the declaration? How can it return ‘memo’ or ‘enumerator’?

The example is pretty good.

In the first paragraph of ‘Embedding a Ruby Interpreter’ the last sentence begins with ‘Install’, it seems that it should begin with ‘Instead’.

to_proc for Symbol is defined only in ruby 1.9 (the little “1.9” sign is missing)

“Compares fix to other numbers. Fixnum.
<, <=, ==, >=, and >.”

I believe “between?” make the list too.

(Dave says" between? is a methodof Comparable)

“Compares flt to other numbers. Fixnum.
<, <=, ==, >=, >, and between?.”.sub(“Fixnum”, “Float”)

“This code assumes soe kind if User class has been written.” should be, “This code assumes some kind of User class has been written.”

“file inslde a directory named anagram/”.gsub(“inslde”, “inside”)

packaging_8.rb

It’s great you’re giving a ruby 1.8 version of require_relative. Saddly, it does not always work. Indeed, ‘caller’ returns lines “in the form file:line or file:line: in ‘method’”.

So at least you must modify the grep pattern. I personally think that the code could be improved (‘e’ is not used, I find using $` ugly, File.join not needed, …). Moreover it would be nicer if it was forward compatible to ruby 1.9 (and other libraries doing the same) by checking if it is not already defined. You are welcome to use my version:

module Kernel
def require_relative(relative_feature)
file = caller.first.split(/:\\d/,2).first
if /\\A\\((.*)\\)/ =~ file # eval, etc.
raise LoadError, “require_relative is called in #{$1}”
end
require File.expand_path(relative_feature, File.dirname(file))
end unless method_defined? :require_relative
end

Thanks!

The closure example may be missing a line of code. Specifically, the proc in Creator#create_block should probably start with

puts “CONST = #{CONST}”

A bit more explanation of the example might also be helpful for people who aren’t quite sure what a closure is.

Just compiled from HEAD. “ri -c” doesn’t list classes, it shows generic help.

(Dave says: I can’t believe they removed that option. Apparently you now run with no options to get the class listing)

“Here we ask and array”

The current punctuation and sentence structure is hard to discern, at least in the PDF:

“We’ve already come across two methods that do
output. puts writes its arguments, adding a newline after each. print also writes its arguments, but with no newline.”

Since “puts” and “print” begin the sentence, and are lowercase (where we English readers expect a capital), and the font doesn’t differentiate enough, I’d suggest:

“We’ve already come across two methods that do
output: puts writes its arguments, adding a newline after each; print also writes its arguments, but with no newline.”

[Obviously I can’t mimic the differing fonts in this suggestion; but the colon and semi-colon help set off “puts” and “print”]

Indeed, the first sentence is introduction of a list, so I expected a colon following, and read right past the period and into “puts”, and I had to break my scanning to study the paragraph more.

In the fourth paragraph of “MiniTest::Unit vs. Test::Unit” box, I believe that you want to delete the first “automatically.”

The following code:

def power_proc_generator
value = 1
lambda { value += value }
end
power_proc = power_proc_generator
puts power_proc.call
puts power_proc.call
puts power_proc.call

will not produce 2, 4, 8. It produces 2, 2, 2

I think you meant: generator = power_proc
puts generator.call
puts generator.call
puts generator.call

This will produce 2, 4, 8

“(or it’s synonym enum_for)” should be “(or its synonym enum_for)”. Apostrophe makes it say “it is”.

“before return a result” -> “before returning a result”

The example at the top of the page has method infinite_select(enum, &block). I believe this is the first time an ampersand is used as a prefix, and there’s no explanation of what it means.

This seems to be the first use of a leading “?” without an explanation of what it does. I’m guessing it’s a way to represent character constants?

The following features are worth to be mentioned in the book :

- simpler way to call a lambda. Ex : my_lambda.(x) instead of my_lambda.call(x)
(I discovered this from Matz Q/A session at RubyConf 2008)
- the constant lookup is no longer lexically scoped. I faced this change in the context of instance_eval.

I know the format isn’t final; however, you may want to ensure the last line, which starts a new paragraph introducing a list (“If r stands for the immediately preceding regular expression within a pattern, then”) is printed with the list without having the reference tables intervening.

“And we can also use RUby-style comments document the tricky stuff.”

The phrase “if you’re using a hash to count the number of each different word occurs in a file” is probably missing the word “times.”

Enumerator.next, .rewind, .with_index are all ruby 1.9 only, so they should have the little “1.9” tag.

PS: Clearly the 1.9 tag was not automatized, I hope there are not too many such errors.

(Dave says: all of Enumerator is new…)

Enumerator.each_with_object and its usage line overlap

In Fig 11.1 & Fig 28.1 (ruby exceptions), I think it would be helpful to show which exceptions are new to ruby 1.9. The note on SecurityError changing in the hierarchy could go as a footnote for both figures.

second line from down in paragraph before ‘Matching Against Patterns’

double time word ‘encoding’

puts“#{word}: #{count}”

A bit nicer output : (\\t added)

puts“#{word}:\\t#{count}”

(Dave says: then I’d have to explain \\t, which I don’t do for another 40 pages…)

It is a tutorial and reference for version 1.9 of the Ruby programming language.
———————————
It is a tutorial and reference for the version 1.9 of Ruby programming language.

Hi,

Atempted to run the code as downloaded in sample form.

Got this error:

om$ ruby stock_stats.rb data.csv
Processing data.csv
/Users/tom/pickaxe/book_in_stock.rb:15:in `Float’: can’t convert nil into Float (TypeError)
\tfrom /Users/tom/pickaxe/book_in_stock.rb:15:in `initialize’
\tfrom /Users/tom/pickaxe/csv_reader.rb:20:in `new’
\tfrom /Users/tom/pickaxe/csv_reader.rb:20:in `block in read_in_csv_data’
\tfrom /opt/local/lib/ruby1.9/1.9.1/csv.rb:1754:in `each’
\tfrom /opt/local/lib/ruby1.9/1.9.1/csv.rb:1190:in `block in foreach’
\tfrom /opt/local/lib/ruby1.9/1.9.1/csv.rb:1328:in `open’
\tfrom /opt/local/lib/ruby1.9/1.9.1/csv.rb:1189:in `foreach’
\tfrom /Users/tom/pickaxe/csv_reader.rb:19:in `read_in_csv_data’
\tfrom stock_stats.rb:15:in `block in

“We could fix this by writing a method which reads the file and yields each successive word. But fibers give us a simpler solution.”

I don’t see how using fibers is any simpler than just writing a block that yields each word. In fact, the example looks like you’re doing just that, but wrapping the block in a Fiber object instead of using a Proc. How’s that simpler? I guess I just don’t get it..what’s the real use case for adding fibers to the Ruby language?

“This code also illustrates a gotcha. Inside the loop, the threads use print to write out the number, rather than puts.”

It uses ‘print’ to output the URL, not a number. Further it uses ‘puts’ to write the “Got:” line; shouldn’t it too use ‘print’?

“you’ll find the top-level for your C: drive at C:
(that’s the drive letter, C, a colon, and a single backslash).”
The backslash is missing after the second C:. It should be C:\\

“puts –1942.abs” warned me “warning: ambiguous first argument; put parentheses or even spaces”. I added parentheses and it worked correctly — “puts(–1942.abs)”

(Dave says: looks like they’ve tightened that up. Thanks)

“When designing a class interface, it’s important to consider just how much of you class
you’ll be exposing to the outside world.”
“you class” should be “your class”.

RSpec sytax -> RSpec syntax

“Merb is a lighterweight alternative to Rails.”

Use lighter-weight instead. I also note that Merb and Rails is merging, so I dunno if you want to change the statement or not.

“The —display option…”

It’s not —display, it’s —details

2nd para: which invokes it’s host class’s each method: its

sprintf entry starts before spawn entry / options is complete

(Dave says: tables such as this float to the tops of pages. I think I’ll move all tables to the end of the section)

In absolute_path it looks like “Path names starting with ~ and not expanded, in contract with File#expand_path.” should read:
“Path names starting with ~ are not expanded, in contrast with File#expand_path.”

In with_object, ‘ynonym’ instead of ‘Synonym’

Just before Why Ruby?
————————
(such as MacRuby—a version of Ruby
that is integrated into the Objective C runtime on the Mac—only run 1.9 code.
————————
Right parenthesis missing, my Lisp interpreter segfaulted :)

Footnote 1
—————————-
The hyperlink seems broken
—————————-

I am not sure if this is a issue, but I imagine that reading the book in paper it is very ugly to find page 23 starting with an URL.
I would maybe try to get the url back to page 22.

(Dave says: we do layout after the content is complete)

At the second line of Part III
—————-
the concept of duck typing, the object model model, metapro-
gramming,
—————-
One model too much.

Hmm this is a tough one.
You suggest correctly to the reader that he will not want to have a /projects directory. (And sometimes will not be able to have one). But then you continue to use /projects as an example.
As you have already introduced the ~ shortcut for $HOME it might be a good idea to use ~/projects in the unix examples.

Last para before “Source Code”.
Up to here you are walking new and unexperienced users through the first steps of using the command line and installing Ruby. Great Job!!! However, in the aforementioned paragraph you throw a “POSIX systems” on them. Is that not risking to be confusing?

Second para after samples/intro_1.rb
——————————————————-
Within each class, you can define instance methods. Each method is a chunk of function-
ality that may be called from within the class and (depending on accessibility constraints)
from outside the class.
————————————-
IMHO that should read:
————————————-
…maybe called from within the object …. outside the object.

Start of text at p.46
———————————————
Each line shows a method being called as an argument to puts. The thing before the period
is called the receiver, and the name after the period is the method to be invoked.
———————————————
If you have used this wording on purpose, sorry. I however suspect from the context that it somehow slipped in; My suggestion would be:
Each line shows the result of a message sent to an object passed as an
argument to puts. The thing before the period
is called the receiver, and the name after the period is the message sent to the receiver.

(Dave says: I never liked the “message” meme, so try not to use it. But “received” is common parlance, so I go with that flow)

Third para:
—————————-
Having defined the method, we call it twice.
—————————-
Actually this phrase is ambiguous (for beginners only of course).
Suggestion
“call”.clear << “invoke”

3rd para
—————————————————-
When Ruby constructs this string object, it looks at the current value of name and substitutes
it into the string.
—————————————————-
… it looks at the current value of name, sends the to_s message to it and substitutes it into…
OR
… it looks at the current value of name, converts it into a string (we will explain this in more detail later, for now it suffices 2 know that it is done in a “natural” way) and substitutes etc.etc.

2nd para
——————————-
Most statements in Ruby return a value, …
——————————-
“Most”.clear << “All” and maybe adding that this value can be nil, as e.g. in the case of puts.

(Dave says: what value is returned by “raise”?)

para 2 after code example
——————————
The part of a string matched by a regular expression can be replaced with different text
using one of Ruby’s substitution methods.
——————————
This is clearly wrong, but somehow I guess this is done on purpose not to confuse nubies too much. Nevertheless it somehow shocks me, I dunno, just a suggestion:
———————————
The part of a string matched by a regular expression can be replaced with different text
using one of Ruby’s substitution methods.

line.sub(/Perl/, ‘Ruby’) # create a new string in which the first occurrence of ‘Perl’ is replaced with ‘Ruby’
line.gsub(/Python/, ‘Ruby’) # create a new string in which all occurrences of ‘Python’ are replaced with ‘Ruby’

Last para of “Command Line Arguments”
——————————————————-
the variable ARGF is a special kind of I/O object that
acts like all the contents of all the files whose names are passed on the command line.
——————————————————-
… on the command line or standard input if no arguments were passed.
——————————————
537/38 > echo “xxx” | ruby1.9 -v -e ‘ARGF.each do | line | p line end’
ruby 1.9.1 (2008-12-01 revision 20438) [i686-linux]
“xxx\
”

The URL for webrick.org is written with three slashes

First sentence of first paragraph under Access Control heading:

When designing a class interface, it’s important to consider just how much of you class

should be ‘your’, ‘the’ works also.

Should say “now know” instead of “know know” in the following sentence:

“This is the second: you know know as much
about regular expressions as the vast majority of Ruby developers.”

Missing / not rendered bold font in
"Generate the wrapper class using the olegen.rb script in the ext\\win32ole\\samples directory,
giving it the name of the type library to reflect on.

C:\\> \\textbf{ruby olegen.rb ‘NetMeeting 1.1 Type Library’ >netmeeting.rb}

The external methods and events of the type library are written as Ruby methods to the
given file. You can then include it in your programs and call the methods directly. Let’s try
some timings.
…"

Under the “Ruby Programs” header, the name TextMate should have caps. IDE should be defined.

The leading paragraph states: “…want to accept any object for the price parameter as long as that parameter can be converted to a float. We can pass in a float, an integer, and even a string…” In the example code following, b1 has an integer, b2 has a float, and b3 has another float, rather than a string which would match your text.

The leading paragraph discusses the misconception that attr declarations somehow declare instance variables. This paragraph could end with the sentence: “Ruby completely decouples instance variables and accessor methods as we see in the upcoming section titled ‘Virtual Attributes’.”

I think the bottom of pg 70 needs to more strongly emphasize that the default protection of a method is public. I had to reread it a couple times. I think it should state (using ’ to show my insertions): "Ruby gives you three levels of protection ‘using the optional keywords public, protected, and private.’
-Public methods can be called by anyone — no access control is enforced. ‘By default, all methods are public (except for initialize, which is always private) unless the keyword protected or private is explicitly specified’.

under the heading Behind the Curtain
“As well as being faster that the old interpreter” should read “As well as being faster than the old interpreter”

“The notation \\k+0> means […]” has one angle bracket too many and should read “The notation \\k<some_letter+0> means […]”

The downloaded code (in the tar file) does not contain the directory structure or file for fib_example.rb

About footnote 7: in Haskell it is implemented as «\\» but there is no way to use it in Ruby since it is reserved.

Inside this text block:

Folks have been using Test::Unit with Ruby for a good number of years
now. However, the core team decided to replace the testing frame-
work that comes as standard with Rails with something a little leaner.
Ryan Davis and Eric Hodel wrote MiniTest::Unit as a par tial drop-in
replacement for Test::Unit.

… should it say Ruby instead of Rails?

please add the ruby one-click installer for osx to the options on how to get/install ruby for mac osx. we are providing packages for i386 and ppc for osx leopard, tiger and panther. macruby is not 1.9.1 yet and will only support leopard from version 10.5.2! we support all kinds of osx systems.
( more information on rubyosx.com )

class String; def please; $stderr.puts “You have done a great job so far”; self end end

para[ –4 ].text.sub( “CEnumerator”, “Enumerator” ).please

Convert int to a rational number.
1.to_r # => 1/1
1.5.to_r # => 3/2
(1.0/3).to_r # => 6004799503160661/18014398509481984

1.5 and 1.0 are not integers so it seems to make no sense to show this examples when describing the Integer class.

Kernel::loop - Returns an Enumerator if no block given.

I don’t see this behavior.

spitfire% ./irb19
irb(main):001:0> RUBY_DESCRIPTION
=> “ruby 1.9.1p0 (2009-02-02 revision 21960) [i386-freebsd6.3]”
irb(main):002:0> p loop
LocalJumpError: no block given
from (irb):2:in `loop’
from (irb):2
from ./irb19:12:in `

Fortunately, Ruby comes with a good CSV library (described on
page ??).

This line doesn’t link to anything. Perhaps the page needs to be written still.

chapter “Proc Objects”, first para last sentence.
There are four ways of converting a block into a Proc object.
——————————————————————————————-
Well there are actually five(1).

def a; Proc::new end
x = a{ 42}
x.call # —> THE Numba

(1) One could argue that this is just a variant of method 1, and I would not disagree too much. In that case however I believe that it is still worth being mentioned.

In the documentation of Proc#lambda? there is a sentence:
See the discussion starting 23 on page 375.
The “23” is a link into page 375 which is within chapter 23, but shouldn’t the text of the link be something like “in Chapter 23”.

pending from page 100, and referring to Ruby1.8
whereas blocks were basically had just a list of names.
—————————————————————
Splat args were perfectly possible:
515/15 > ruby186 -v -e ‘x=proc{|*args| args.join(“, ”)}; p x.call( :alpha, :centauri )’
ruby 1.8.6 (2009-01-06 patchlevel 291) [i686-linux]
“alpha, centauri”

At the bottom of the page, “You can use the back-
slash escapes shown in 23.2 on the next page.”
The 23.2 is a link to Table 23.2. Other references include the “Table” to make that clear.

At the end of the description of “[characters]”, there is " See 134." where the 134 is a link to that page. The text should say “See page 134.”

2nd para private methods: self is used without prior explanation.
This repeats itself on pp 88, 94, 95 & 103. On page 103 self is eventually explained in a very short term.
————————————————————-
Maybe this is perfectly ok for the level of audience this book is written for. If however it is an oversight I wanted you to give the chance to fix it.

definition of #get_end_of_log_file
Would it not be nicer and in accordance to a suggestion made earlier (p.95) to write the method as follows
File.open(“/var/log/system.log”){ | log |
log.seek(–1000, IO::SEEK_END) # back up 1000 characters from end
log.gets # ignore partial line
log.read # and return rest
}
—————
I know you will prefer do…end but I am part of the, not so small, minority which uses { } for all blocks of which the return value is used and do end for all others.

At the paragraph starting the page:
“See 18 on page 275 for more information.”
Saying “See Chapter 18 ….” would be more clear.

module Trig
….
def Trig.sin
etc.etc.
———————————————
An avert reader might remark that this causes problems when one wants to change the module’s name. IOW it’s not DRY

modue Trig
def self.sin
et altri
end

First para in Debug#who_am_i?
“#{self.class.name} (\\##{self.object_id}): #{self.to_s}”
————
Suggest to get rid of the superfluous “.to_s”

(Dave says: I want to make it explicit here)

2nd text para
is:
The Ruby include statement
simply makes a reference to a named module.
——————————-
should be:
The Ruby include statement
simply makes a reference to a module.

paras.last
Well I really do not like this sentence:
All you have to do is write an iterator called each, which returns the elements of your collection in turn.
—————————-
If you are happy with it just skip the rest, but maybe you are not either. Are you sure that one can call a method that yields an iterator? If so sorry for wasting your time…

Last para before chapter “Resolving Ambiguous …”
A downside of this approach is that the data associated with a particular object will not get
automatically deleted if the object is deleted.
——————————-
Maybe one could add a footnote mentioning that this issue could be solved by a hash holding weak references, which would be a little bit too complex to be shown here.

First text para
You have three more ways to construct string literals: %q, %Q, and here documents.
%q and %Q start delimited single- and d….
—————————-
As a

continued
As a matter of fact %Q is rarely used as the Q is optional.
In order for readers to understand codes of others this seems very important.

In the context of string literals.
Maybe it might be noteworthy that " . . . " as well as %[Q]< . . . >
can contain line breaks. A rather unusual feature.

Missing space in “Ruby 1.9has changed the way Ruby looks up constants when…”

Under: Pattern-Based substitution, first para:
Reads: We’ve already “see” …
Should Read: We’ve already “seen”

Under: Controlling Backtracking, 2nd para, line 6:
Reads: the engine goes back and “tried”
Should Read: the engine goes back and “tries”
Or the engine “went” back and tried

“which claims to offered a packaged OX X […]” should be OS X.

Matching Against Patterns
=
1st para:
Once you have a regular expression object, you can match it against a string using the
Regexp#match(string) method or the match operators =~ (positive match) and !~ (negative
match).
—————————————————————-
Regexp#=== is missing in the list above.

(Yes, but that’s not a bug)

last line in code on page
Do not use “ll” but rather “alle” or something more easily distinguishable. At first I did not understand why “11” matches “Fats Waller”. I hate ambiguous fonts.

end of first para:
————————————————————-
Given a MatchData object, you can call pre_match to return
the part of the string before the match, post_match for the string after the match, and index using [0] to get the matched portion.
————————————————————
… and to_s or the [] method with parameter 0 to get the matched portion.

There is no MatchData#index method.

Last, parenthesized, line:
Actually, \\Z matches the end of a string unless the string ends with a \
, in which case it matches just before the \
.)
——————————————————————
should be:
Actually, \\Z matches the end of a string unless the string ends with a \
and the regular expression is not in Multiline Mode, in which case it matches just before the \
.)
——————————————————
518/21 > ruby19 -ve ‘p( /\\A.*\\Z/m.match( “a\
” ))’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
#<MatchData “a\
”>
robert@siena:~ 17:23:35
519/22 > ruby19 -ve ‘p( /\\A.*\\Z/.match( “a\
” ))’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
#<MatchData “a”>
==
Personally I hate it. It really follows the “implementation” logic and not the “user” logic. Would you care lobbing against this? Please!!! ;)

Character Classes
=
The significance of the special regular expression characters—
. | ( ) [ { + ^ $ * ?—is turned off inside the brackets.
——————————————-
Not the [ anymore :(

532/36 > ruby19 -ve ‘p( /[[a]/.match( “a[” ))’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
-e:1: premature end of char-class: /[[a]/
534/38 > ruby19 -ve ‘p( /[\\[a]/.match( “[a” ))’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
#<MatchData “[”>

In the “The very latest Ruby” box,
“You can check files out as an
anonymous user from their archive by executing the following SVN
commands:
$ svn co http:/ /svn.rubylang.
org/repos/ruby/trunk ruby” (sorry had to add a space in the http because of the spam filter here)

There is just one (1) command, so “commands” doesn’t need a “s”.

Missing reference to “OO Refresher”
—————
“[…] you might want to have a quick look at the notes starting on page ??.”

Maybe this content isn’t written yet? I took a quick look through the index and couldn’t find what it would be….

(Dave says: removed the reference—I had to trim that section for size reasons)

I don’t think the %s notion to create a symbol is a 1.9 feature. It works in 1.8 as well.

Section “General Delimited Input”: Aren’t these so-called “fancy strings”? One could mention this, maybe.

(Dave says: I’ve never heard that term)

Last line of second paragraph: Shouldn’t it be “mostly everything” instead of “most everything”? Sorry if I’m wrong.

(Most likely.. :)

Interface for first has two mistakes:
enum.first → int or nil => enum.first → obj or nil
enum.first(⟨n⟩∗) → an_array => enum.first(n) → an_array

In the section for “to_a”: “a object” instead of “an object”.

“to_path”: Missing closing parantesis “)” at end of line.

In the extended regexp’s comment: “palindrone” instead of “palindrome”.

I had initially glossed over the fact that attr_reader is a get-only function. You might want to add a sentence like this -
Note: This is a read-only attribute.

Yes, when you get to attr_accessor and attr_writer, it becomes obvious, but I think others might find this comment helpful…

“ERB breaks its input text into checks of regular text and program fragments.”

probably meant to say:

“ERB breaks its input text into chunks of regular text and
program fragments.”

In the last code snippet of the chpater “instance_eval and Domain-Specific Language” there is the instance variable size but in the following three lines explaining the code the instance variable is called count.

SystemStackError was under StandardError in Ruby 1.8, too! :-)

In the -E switch documentation: “Specifies
the default character encoding for date read […]”. The word “date” should be “data”, I think.

Documentation for -E switch: “([…] to this when write, and transcoded from […])”. The word “write” before the comma should be “read”.

In the first paragraph under “Encodings” in the second line: repeating of word “method”.

In the table 28.15 (Options to encode and encode!): In the description of :invalid, “If :invalid not …” should be “If :invalid is not …”. Same for :undef.

Description of -e option: The programfile has to be ommitted. Even if specified, it is ignored. And ranges of integers don’t match against the current input line nummer. I’ve tested with: echo -e “foo\
bar\
baz\
blih\
blah” | ruby -ne ‘print if 1..2’

(Dave says: I believe this is a Ruby bug)

In the last line: “The method Object#untrusted? returns true is an object is untrusted.”. Replace the first “is” with “if”.

Text under figure doesn’t have serifes.

(Dave says: it’s the caption…)

Text under figure doesn’t have serifes. Same for page 303.

(Dave says: it’s the caption)

“Gems gets around this issue.” should be “Gems get around this issue.”

(Dave says: ‘Gems’ is singular—it is RubyGems)

reutns
Once our sum has been calculated, we need to get it back into our C code. The call to
rb_gv_get gets the value of a global variable, but reutns it as a Ruby object. We use NUM2INT
to convert it to a native integer before printing the result (which is 55).

The heading “Method Return Values” should be “Methods Return Values”.

(The following example would be better written using fibers.)
———————————————————————-
I do not see how fibers can have synchronization issues?
When a fiber yields it cannot wait on a CV at the same time? Or do I miss something here?

page.paras[1].sentences[–1].sub( “tothe”, “to the” )
—————————————————————————-
I know this is embarrassing, but it is like Python, whitespace matters ;)

Third para after code
———————————
Ruby makes this singleton class the class of the “cat” object, and makes String (which was
the original class of “cat”) the superclass of the singleton class. This is shown in Figure 25.2
on the following page.
————————————————-
Unfortunately that is not “true”: Maybe the bug is rather in Ruby than in the book, you decide, but here is what Ruby tells me:
robert@siena:~/SW/ruby-1.9.1-p0 19:02:00
491/3 > ruby -v -e ‘animal=“cat”; class << animal; def a; 42 end end; p animal.class; p animal.a’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
String
42
robert@siena:~/SW/ruby-1.9.1-p0 19:02:42
492/4 > ruby -v -e ‘animal=“cat”; def animal.a; 42 end; p animal.class; p animal.a’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
String
42

BTW the following holds too
494/6 > ruby -v -e ‘animal=“cat”; p animal.is_a?( class << animal; self; end )’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
true

(Dave says: singleton classes are not revealed by .class)

Last sentence of third para
The class in inserted…
————————————-
The class is inserted

code at top of page
module ClassMethods
…
def self.included(host_class)
host_class.extend(ClassMethods)
end
——————————————-
I feel that
host_class could be named host_module which is more general and that
host_module.extend ClassMethods
could be rewritten as
host_module.extend self
which seems to be more in the spirit how you wrote code in this section. ( And dryer of course!)

About 12th line from the top:
It says: “Procs, , break, and next”. There are two commas one after each other.

In a paragraph “self and Method Calling”, at end of 4th sentence, missing closing parantesis.

The first sentence in the “Eight-bit Clean Encodings” section (see below) uses the word “made-up” which denotes “imaginary” colloquially but may denote “consists of” technically to non-native English speakers.

I would suggest changing “made-up” into “imaginary” to avoid confusion.

“Ruby supports a made-up encoding called ASCII-8BIT.”

becomes:

“Ruby supports an imaginary encoding called ASCII-8BIT.”

“to” should be “too” in “class methods in a parent class are available to in the child class.” (or just strike “to”).

first para of chapter “method_missing” hook.
However, Ruby predefines its own version of method_missing in class Object, so typically the search stops there.
———————————————————————————
That seems not to be true:

516/17 > ruby -v -e ‘p Object.instance_method( :instance_eval )’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
#<UnboundMethod: Object(BasicObject)#instance_eval>

However there are two issues with this right now:
Bug #1185 & Bug #1186

Sorry, wrong copy and paste in the previous post:
Here is what you need:

579/84 > ruby -v -e ‘p BasicObject.instance_method( :method_missing )’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
#<UnboundMethod: BasicObject#method_missing>

samples/ospace_21.rb contains a call to Kernel.proc which you discouraged the use of earlier in the book (page 376, footnote #7).

IMHO it isn’t clear from the descriptions of rdoc’s directives that those directives are not parsed when being put into an included text file, i.e. you cannot put the :main: directive into README.TXT, which seems natural somehow, but only into a ruby file.

line 1 paragraph 4 reads ‘In Ruby 1.9, arguments with …’ should read ‘In Ruby 1.9, arguments without default values may appear after arguments with defaults.’

In the discussion of to_ary at the bottom of the page, it says that Ruby 1.9 uses to_splat to do implicit conversion instead of to_ary.

While this was true for a while during the Ruby 1.9/1.9.0 period, Matz undid that experiment and Ruby 1.9 still uses to_ary. Grepping the Ruby 1.9 source code for to_splat finds no hits.

(Dave says: good catch)

Just under the first code example on the page “But what it you wanted” should be “But what if you wanted” ##Notice the it should be if##

str.gsub(/\\\\/, ‘\\\\\\\\\\\\\\\\’) # => “a\\\\b\\\\c” (ruby 1.9.1p0 (2009-01-30 revision 21907)

(Dave says: youre in irb, right? It displays strings in #inspect format by default)

Shouldn’t the last word in the “The Very Latest Ruby” gray box be “command” rather than “comment”?

—disable-gems isn’t included in the list produced by ruby -h for ruby 1.9.1p0 (2009-01-30 revision 21907)

(Dave says: this is bug in Ruby)

-U isn’t included in the list produced by ruby -h for ruby 1.9.1p0 (2009-01-30 revision 21907)

(Dave says: this is a bug in Ruby)

-X and -y, -yydebug aren’t included in the list produced by ruby -v for ruby 1.9.1p0 (2009-01-30 revision 21907)

(Dave says: this is a bug in Ruby)

“This second contains” perhaps should be either “This section contains” or “This second section contains”.

samples/tutstdtypes_23.rb and surrounding text look like the first place the notion of “Struct” is used. (Moreover, there is no explanation of what a Struct is at that point in the text). This was a foreign concept when I got to that point in the text on first reading. A little googling and searching in the Pickaxe book made clear what a Struct is, but you might want to add a brief explanation or use another programming concept at that point.

In the bottom of gray box in the ordered list number 3 starts with “You’ll can install” and it should be “You can install”.

There is a sentence “When the function terminates.” that makes no sense in the context. Should it have a comma instead of a full-stop?
This occurs in the paragraph that begins “Internally, rb_tbr releases the GVL, then calls the function you specify”.

Dot-point 3 of “Building Our Extension” says “This is what happens on an OS X system.” The way its worded and with the full-stop at the end gave me the impression that you can only build extensions on OS X, rather than the example output happening to be the OS X version of running make. Perhaps say “If run on an OS X system, this is what would happen”

In the last sentence of the first paragraph: “…as we’ll see [in] the section….”

The irb configuration options list prompt_i, prompt_c, and prompt_s. There is no mention of prompt_n, though. It took me a while to find a way to format the inner lines of method definitiions.

in samples/taint2.rb
do not use
f.open
f.print
f.close
but the blockform of open.

2nd para
The safe level in effect when a Proc object is created is stored with that object. The safe
level may be set during the execution of a proc object without affecting the safe level of the
code that invoked tha proc. A proc may not be passed to a method if it is tainted and the
current safe level is greater than that in effect when the block was created.

Seems this holds only for $SAFE=4, look at this please:
for i in 1 2 3 4 ; do
> ruby -ve ‘x=lambda{ p $SAFE }.taint;p x.tainted?; $SAFE=’$i’; def a; yield end; a(&x)’
> done
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
true
1
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
true
2
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
true
-e:1: warning: $SAFE=3 does no sandboxing; you might want to use $SAFE=4
3
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
true
-e:1:in `

I misinterpreted the stack trace in the above Erratum; Even at level 4 a tainted proc can be passed to a method.
ruby -ve ‘def a; yield end;p method(:a).taint; x=lambda{ $SAFE }.taint;p x.tainted?; $SAFE=4; a(&x)’
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
#<Method: Object#a>
true

This section feels unfinished.
1) Many interface return → end or → enc instead of → encoding
2) Many examples are missing (or misleading, like default_internal=)

double period…
“Chad Fowler and Andy Hunt..”

command “ri GC” now has additional method (malloc_allocated_size, malloc_allocations) and returns…

——————————————————————————————— Class: GC
The GC module provides an interface to Ruby’s mark and sweep
garbage collection mechanism. Some of the underlying methods are
also available via the ObjectSpace module.

Class methods:
———————

count, disable, enable, malloc_allocated_size, malloc_allocations,
start, stress, stress=

Instance methods:
————————-

garbage_collect

results for typing ri assoc now returns four results and is now …

more than one method matched your request. You can refine your
search by asking for information on one of:

Array#assoc [Ruby 1.9.1]
Array#rassoc [Ruby 1.9.1]
Hash#assoc [Ruby 1.9.1]
Hash#rassoc [Ruby 1.9.1]

the use of number as the name of your number variable at first makes the example look like number is a special object to call when you want to test the length of a number. Whereas, mynumber or any specific naming more clearly shows that it is just the creation of any object with a numeric value.

See below….
——————————————————————————
number = Math.abs(number) // Java code
In Ruby, the ability to determine an absolute value is built into numbers—they take care of
the details internally. You simply send the message abs to a number object and let it do the
work.
number = –1234 # => –1234
positive = number.abs # => 1234

But what it you wanted to iterate and receive an index, but use a different method than each
to control that iteration?

should read

But what IF…

On page 735, the footnote says that leap seconds are used because “years are not really a convenient number of hours long”. But aren’t leap seconds used because days are not a constant number of seconds (because the earth’s rotation is not constant), and leap days used to handle the fact that years doesn’t have an integer number of days?

This erratum also happens in the first and second edition.

Hash::index is deprecated. This should show in the doc (and not in the example).

in the first line: it should be “previous two editions” missing s on edition

Enumerable::each_with_object takes an optional block, which should be specified in the interface line

In “enum.each_cons( length ) [ {| array | block } ]”, why the []? If it’s because the block is optional, then the [] are missing in most methods of enumerator. Otherwise they should go (same with each_slice)

Dear Dave, Thanks for the great book. If still possible I do want to make one suggestion for the chapter IRB. One very handy feature of the IRB is the use of _ which refers to the last result. So:
>> 3+2
=> 5
>> _ + 5
=> 10

Quoting the book: “The order in which keys and/or values are returned by the various iterators over hash contents may seem arbitrary and will generally not be in insertion order.”

This is no longer true for Ruby 1.9. Order is maintained.

Thanks for the great book. Looking forward to my paper copy.

“the variable d is not shared before it occurs only inside the block” should be “the variable d is not shared because it occurs only inside the block”.

End of first para:
“Given a MatchData object, you can call pre_match to
return the part of the string before the match, post_match for the string after the match, and
index using [0] to get the matched portion.”

Funny I never used [0] for that purpose before, always #to_s.
Maybe this approach is worth being mentioned too? YAF?

In Figure 4.1, the picture for a[1…3] is missing the right-side border of the box around “cat”

The link in the last paragraph of the “Windows Distributions” extends past the right margin and even the right edge of the page (although it does go to the rubyinstaller page on RubyForge).

Enumerable::reverse_each should have the “1.9” symbol since it is new.
Array::reverse_each is incorrectly described: the block is now optional. It probably shouldn’t be there since it inherits the reverse_each from Enumerable.

Beginning of Enumerator::new states “The second form constructs…”. Should read “The first form constructs…”

“with the method Kernel#to_enum (or via its alias, Kernel#enum_for).”.gsub(“Kernel”,“Object”)

Interface of Hash#rassoc missing the closing parenthesis.

Hash#delete_if: interface probably shouldn’t have the ⟨ ⟩ around the block. Same with Hash#reject!

First line of text: “generator-lke” should be “generator-like”

Interface of String#gsub has second and third form on the same line

The page numbers in the Table of contents, index, etc. are 1 too small

For “readbyte”, it says “Returns the next 8-byte byte”. I suspect this should be “8-bit byte”.

The first line of the description of slice! starts “Deletes the specified portion from strand…..”

There is a space missing between “str” and “and”.

This line looks a bit sketchy:
Available only with the
-n or -p command-line options are present.

The specification of the method “to_hash” says "see page 375. I think this should be page 378.

In the specification of slice!, it says that “this is a string”.slice!(3..6) returns " is “. When I try it I get ”s is".

The page numbers in cross references are 1 below what they should be.

obj =~ other_obj
→ !(obj=~ other_obj)

should be

obj !~ other_obj
→ !(obj=~ other_obj)

Enumerable#detect should have a “1.9” symbol next to it, since it can now be called without a block

In Array#cycle, the following should be removed:
“Equivalent to enum.to_a.cycle. See Array#cycle”
since… we are at Array#cycle!

Interface of Array#frozen: “frozen?!”.gsub(“!”,“”)

Missing “)” in interface after “hsh.assoc( key”

Apparently, there was a mixup between ∂ (U+2202) and δ (U+3B4). All examples are given with δ but the codepoints are those of ∂. Thus there are many errors in the book, in this section and in the String reference section.

String#upto has a second optional argument.

I believe the syntax Enumerator.new{ some block } is new to Ruby 1.9 and thus should have a “1.9” symbol next to it.

The bottom of the page describing Marshal is cut off.

Missing closing parenthesis after + in Object#to_enum interface

In Ruby 1.9, retuns an enumerator if no block is given.

Method#arity refers to Method#parameters. AFAIK, such a method does not exist (yet).

Oups, sorry, I meant to say Numeric#step returns an enumerator if no block is given (in Ruby 1.9), so the interface should change, and a “1.9” symbol should be added.

“It’s” should not have an apostrophe in “the module uses it’s random_bytes method”

Enumerable#find_index can also be given a single argument (as shown in Array#find_index)

Array#find_index returns an enumerator if no block and no argument is given

“subsubtring” where “substring” should be used: “You’ll sometimes want to match a pattern only if the matched subsubtring is preceded by or followed by some other pattern.”

Either the word “refer” or the word “count” should be removed from this sentence: “Negative backreference numbers refer count backward from the place they’re used, so they are relative, not absolute numbers.” I think “refer” should go.

Enumerator#next is 1.9 only, so there should be a “1.9” symbol next to it.

The ‘members’ instance method of Struct returns an array of symbols rather than strings, and this is a change in 1.9.

members joe.members →array
Returns an array of strings (s/b symbols) representing the names of the instance variables.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new(“Joe Smith”, “123 Maple, Anytown NC”, 12345)
joe.members # => [:name, :address, :zip]

#39013: The bottom of the page describing Marshal is cut off.—Dave Thomas

1, Erratum noted above references page 584, should be 574
(at least it is in my paper copy :-) )

2. What, if any, information is missing ?
(my page ends with : newt.other_data # => “wibble”
along the very bottom edge of the page…)
(the next page starts with the Module constants section)

“that is, any? will return true…” should read “that is, one? will return true…”

I can not reproduce the behavior of class variable as described on pages 337 and 338 of Programming Ruby 1.9.

Here is a file with Ruby code I typed in from the text:

##### begin classvars.rb
class Holder
@var = 99 def Holder.var=(val) var = val end def var @var
end
end

@@var = “top level variable”

a = Holder.new
puts “a.var: #{a.var}”
Holder.var = 123
puts “a.var: #{a.var}”

def a.get_var
@@var
end

puts “a.get_var: #{a.get_var}”
puts “@var: #{@var}”

##### end classvars.rb

(Essentially, this is the code from the text using puts to produce output. Also, at the end, I show the value of the top level variable @@var.)

Here is the Ruby version and the output I see:

$ ruby -v
ruby 1.9.1p0 (2009-01-30 revision 21907) [i686-linux]
$ ruby classvars.rb
a.var: top level variable
a.var: 123
a.get_var: 123
@@var: 123

With respect to erratum #39185, I tried the same code on an older Ruby build:

$ ruby -v
1.9.0 (2006-06-08) [x86_64-linux]

With this version, the output agrees with the text:

$ ruby1.9 classvars.rb
a.var: 99
a.var: 123
a.get_var: top level variable
@@var: top level variable

Perhaps this is a Ruby bug in 1.9.1p0 instead of a book erratum?

Hash.[] has two other forms. The second and third form take a single argument which is either an array of key-value pairs or an object convertible to a hash.

See redmine #1385, confirmed ruby-core #23433

Assignment method is:

def price_in_cents=(cents)
@price = cents / 100
end

Shouldn’t the middle line be:
@price = Float(cents) / 100 ?

Puts on my system give 12 and 1200 without the Float(…)

Am I missing something here? Thanks.

Some text was cut away, last text was: " have an exact internal representation. When we "

Description of $stdout states: “Assignment to $stdout is not permitted: use $stdout.reopen instead.”

I believe this is not exact. STDOUT can’t be reassigned (obviously since it is a constant), but $stdout is a variable and has STDOUT as default value, but can be reassigned. See The Ruby Programming Language, for intance to section 9.7.1.4, or search ruby’s source code for “$stdout = ”

The first section of the Enumerator description says:
“Some of the methods in the Enumerable module can return an Enumerator object”

But the example you give actually returns an Array…?

When I look at the method used (take_while) you would only get an Enumerator object if no block is given. But you give a block.

The second paragraph for section “break, redo, next, and retry” says: “retry restarts the loop, reevaluating the condition.” However on page 147 there’s a footnote saying “Prior versions of Ruby also supported the retry keyword as a looping mechanism. This has been removed in Ruby 1.9.”

The description for first form of ‘case’ expressions says: “case when condition …” while the description for “if” and other similar expressions says: “if boolean-expression …”. So this implies there’s a difference between a ‘condition’ in a “when” clause and a ‘boolean-expression’ in “if”. However the book doesn’t say anything about what the difference might be.

First paragraph says: “… A module may contain class and instance methods and may define constants and class variables. As with classes, module methods are invoked using the Module object as the receiver…”. The term of ‘module methods’ is not defined anywhere. Presumably they are class methods defined in a module.

First paragraph for ‘Calling a Proc’ says: “You can call a proc by invoking its methods call, yield, or []. The three forms are identical.” No examples is given for the third form. I doubt it’s really identical to the others. Usually when calling a [] method you need to put something between the brackets.

Second paragraph for ‘Calling a Proc’ says: “You can also invoke a proc using the syntax name.(args…). This is mapped internally into a.call(…).” Who’s ‘a’ and where do ‘name’ and ‘args’ go? Maybe it wants to say “name.call(args…)”?

Second line in first paragraph has “exceptioons”.

Last paragraph says: “Previously, constants were looked up in the lexical scope in which there were referenced.” It should be “…they were referenced.”

First paragraph ends with “Because of this, most people are moving away from this style of CFinstance_evaled block.” Not clear what ‘CF’ stands for. Maybe a font marker?

The second paragraph has ‘expectations’ misspelled twice: “expections” in the second line and “expecations” in the fourth line.

The header for class Object shows it has not superclass. However in Ruby 1.9 it has BasicObject as superclass.

The paragraph under ‘Interactive Configuration’ says: “For example to change your prompt back to DEFAULT you could use the following:” but then the code is ‘conf.prompt_mode = :SIMPLE’.

Second paragraph, third line: “tha” should be “the” (“the safe level of the code that invoked tha [sic] proc”).

Technically, one might say that a :fox is “vulpine”. One would use “lupine” for a :wolf, maybe. :-)