Merge pull request #9 from ruby-hacking-guide/ch2-objects-edits

Minor edits to Chapter 2 - Objects

Author: markburns

object.textile

@@ -10,16 +10,15 @@ h2. Structure of Ruby objects
 
 h3. Guideline
 
-Starting from this chapter we will explore the `ruby` source code, starting by
-studying the declaration of objects structures.
+In this chapter we will begin exploring the `ruby` source code, starting by
+studying the declaration of object structures.
 
-What are the required conditions to make sure objects can exist? Many
-explanations can be given but in reality there are three conditions that must
-be obeyed:
+What do objects need to exist? There are many answers to this question, but for
+our purposes an object only needs three things:
 
-# Being able to differentiate itself from the rest (having an identity)
-# Being able to reply to requests (methods)
-# Keeping an internal state (instance variables)
+# The ability to differentiate itself from other objects (an identity)
+# The ability to respond to messages (methods)
+# The ability to store internal state (instance variables)
 
 In this chapter, we are going to confirm these three features one by one.
 
@@ -28,9 +27,9 @@ briefly look at other files such as `object.c`, `class.c` or `variable.c`.
 
 h3. Structure of `VALUE` and objects
 
-In `ruby`, the contents of an object is expressed by a `C` structure, always
-handled via a pointer. A different kind of structure is used for each class,
-but the pointer type will always be `VALUE` (figure 1).
+In `ruby`, the contents of an object are expressed by a `C` structure, always
+handled via a pointer. A different kind of structure is used for each class, but
+the pointer type will always be `VALUE` (figure 1).
 
 !images/ch_object_value.png(`VALUE` and structure)!
 
@@ -124,15 +123,15 @@ RARRAY(arr)->len;    /* ((struct RArray*)arr)->len */
 </pre>
 
 Another important point to mention is that all object structures start with a
-member `basic` of type `struct RBasic`. As a result, whatever the type of
-structure pointed by `VALUE`, if you cast this `VALUE` to `struct RBasic*`,
-you will be able to access the content of `basic`.
+member `basic` of type `struct RBasic`. As a result, if you cast this `VALUE` to
+`struct RBasic*`, you will be able to access the content of `basic`, regardless
+of the type of structure pointed to by `VALUE`.
 
 !images/ch_object_rbasic.png(`struct RBasic`)!
 
-You guessed that `struct RBasic` has been designed to contain some important
-information shared by all object structures. The definition of `struct RBasic`
-is the following:
+You probably guessed that `struct RBasic` has been designed to contain some
+important information shared by all object structures. Here is the definition
+for `struct RBasic`:
 
 ▼ `struct RBasic`
 
@@ -167,9 +166,8 @@ pointer to) a Ruby object. In short, it is a class object.
 The relation between an object and its class will be detailed in the "Methods"
 section of this chapter.
 
-By the way, the name of this member is not `class` to make sure it does not
-raise any conflict when the file is processed by a C++ compiler, as it is a
-reserved word.
+By the way, this member is named `klass` so as not to conflict with the reserved
+word `class` when the file is processed by a C++ compiler.
 
 h4. About structure types
 
@@ -231,19 +229,20 @@ I'll explain them one by one.
 
 h4. Small integers
 
-As in Ruby all data are objects, integers are also objects. However, as there
-are lots of different instances of integers, expressing them as structures
-would risk slowing down execution. For example, when incrementing from 0
-to 50000, just for this creating 50000 objects would make us hesitate.
+Just like in Ruby itself, all data are objects. Likewise, integers are objects.
+However during normal program execution, lots of instances of integers are
+created. Using structures to express them would risk slowing down execution. For
+example, if we created 50000 objects when incrementing from 0 to 50000 we'd
+definitely have to consider the performance issues.
 
 That's why in `ruby`, to some extent, small integers are treated specially and
-embedded directly into `VALUE`. "small" means signed integers that can be held
+embedded directly into `VALUE`. "Small" means signed integers that can be held
 in `sizeof(VALUE)*8-1` bits. In other words, on 32 bits machines, the integers
 have 1 bit for the sign, and 30 bits for the integer part. Integers in this
 range will belong to the `Fixnum` class and the other integers will belong to
 the `Bignum` class.
 
-Then, let's see in practice the `INT2FIX()` macro that converts from a C `int`
+Let's see in practice the `INT2FIX()` macro that converts from a C `int`
 to a `Fixnum`, and confirm that `Fixnum` are directly embedded in `VALUE`.
 
 ▼ `INT2FIX`
@@ -271,7 +270,7 @@ containing `NUM` can manage both `Fixnum` and `Bignum`. For example if
 `INT2NUM()` can't convert an integer into a `Fixnum`, it will automatically
 convert it to `Bignum`. `NUM2INT()` will convert both `Fixnum` and `Bignum` to
 `int`. If the number can't fit in an `int`, an exception will be raised, so
-there is not need to check the value range.
+there is no need to check the value range.
 
 h4. Symbols
 
@@ -301,11 +300,11 @@ troublesome to handle all of them as strings (`char*`), because of memory
 management and memory management and memory management... Also, lots of
 comparisons would certainly be necessary, but comparing strings character by
 character will slow down the execution. That's why strings are not handled
-directly, something will be associated and used instead. And generally
+directly, something will be associated and used instead. And generally that
 "something" will be integers, as they are the simplest to handle.
 
 These `ID` are found as symbols in the Ruby world. Up to `ruby 1.4`, the
-values of `ID` where converted to `Fixnum`, but used as symbols. Even today
+values of `ID` were converted to `Fixnum`, but used as symbols. Even today
 these values can be obtained using `Symbol#to_i`. However, as real use results
 came piling up, it was understood that making `Fixnum` and `Symbol` the same
 was not a good idea, so since 1.6 an independent class `Symbol` has been
@@ -380,10 +379,11 @@ For `Qnil`, there is a macro dedicated to check if a `VALUE` is `Qnil` or not,
 
 The name ending with `p` is a notation coming from Lisp denoting that it is a
 function returning a boolean value. In other words, `NIL_P` means "is the
-argument `nil`?". It seems the "`p`" character comes from "predicate". This
+argument `nil`?". It seems the "`p`" character comes from "predicate." This
 naming rule is used at many different places in `ruby`.
 
-Also, in Ruby, `false` and `nil` are false and all the other objects are true.
+Also, in Ruby, `false` and `nil` are falsy (that is, they count as false in
+conditional statements) and all the other objects are truthy.
 However, in C, `nil` (`Qnil`) is true. That's why in C a Ruby-style macro,
 `RTEST()`, has been created.
 
@@ -403,7 +403,7 @@ requirements of the glib library that only wants 0 or 1
 ("[ruby-dev:11049]":http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-dev/11049).
 
 By the way, what is the '`Q`' of `Qnil`? 'R' I would have understood but why
-'`Q`'? When I asked, the answer was "Because it's like that in Emacs". I did
+'`Q`'? When I asked, the answer was "Because it's like that in Emacs." I did
 not have the fun answer I was expecting...
 
 h4. `Qundef`
@@ -421,10 +421,10 @@ be found at all at the Ruby level.
 
 h2. Methods
 
-I already brought up the three important points of a Ruby object, that is
-having an identity, being able to call a method, and keeping data for each
-instance. In this section, I'll explain in a simple way the structure linking
-objects and methods.
+I already brought up the three important points of a Ruby object: having an
+identity, being able to call a method, and keeping data for each instance. In
+this section, I'll explain in a simple way the structure linking objects and
+methods.
 
 h3. `struct RClass`