Editing pass on debugging guide.

1 files changed, 106 insertions, 86 deletions

diff --git a/railties/doc/guides/debugging/debugging_rails_applications.txt b/railties/doc/guides/debugging/debugging_rails_applications.txt
index f7538cd08b..24eb0c0431 100644
--- a/railties/doc/guides/debugging/debugging_rails_applications.txt
+++ b/railties/doc/guides/debugging/debugging_rails_applications.txt
@@ -1,7 +1,7 @@
 Debugging Rails Applications
 ============================
 
-This guide covers how to debug Ruby on Rails applications. By referring to this guide, you will be able to:
+This guide introduces techniques for debugging Ruby on Rails applications. By referring to this guide, you will be able to:
 
 * Understand the purpose of debugging
 * Track down problems and issues in your application that your tests aren't identifying
@@ -18,7 +18,7 @@ One common task is to inspect the contents of a variable. In Rails, you can do t
 
 === debug
 
-`debug` will return a <pre>-tag that has object dumped by YAML. Generating readable output to inspect any object.
+The `debug` helper will return a <pre>-tag that renders the object using the YAML format. This will generate human-readable data from any object. For example, if you have this code in a view:
 
 [source, html]
 ----------------------------------------------------------------------------
@@ -29,8 +29,9 @@ One common task is to inspect the contents of a variable. In Rails, you can do t
 </p>
 ----------------------------------------------------------------------------
 
-Will render something like this:
+You'll see something like this:
 
+[source, log]
 ----------------------------------------------------------------------------
 --- !ruby/object:Post
 attributes:
@@ -59,10 +60,11 @@ Displaying an instance variable, or any other object or method, in yaml format c
 </p>
 ----------------------------------------------------------------------------
 
-`to_yaml` converts the method to yaml format leaving it more readable and finally `simple_format` help us to render each line as in the console. This is how `debug` method does its magic.
+The `to_yaml` method converts the method to YAML format leaving it more readable, and then the `simple_format` helper is used to render each line as in the console. This is how `debug` method does its magic.
 
 As a result of this, you will have something like this in your view:
 
+[source, log]
 ----------------------------------------------------------------------------
 --- !ruby/object:Post
 attributes:
@@ -79,7 +81,7 @@ Title: Rails debugging guide
 
 === inspect
 
-Another useful method for displaying object values is `inspect`, especially when working with arrays or hashes, it will print the object value as a string, for example:
+Another useful method for displaying object values is `inspect`, especially when working with arrays or hashes. This will print the object value as a string. For example:
 
 [source, html]
 ----------------------------------------------------------------------------
@@ -92,6 +94,7 @@ Another useful method for displaying object values is `inspect`, especially when
 
 Will be rendered as follows:
 
+[source, log]
 ----------------------------------------------------------------------------
 [1, 2, 3, 4, 5]
 
@@ -100,11 +103,13 @@ Title: Rails debugging guide
 
 == The Logger
 
-=== What is it?
+It can also be useful to save information to log files at runtime. Rails maintains a separate log file for each runtime environment.
 
-Rails makes use of ruby's standard `logger` to write log information. You can also substitute another logger such as `Log4R` if you wish.
+=== What is The Logger?
 
-If you want to change the logger you can specify it in your +environment.rb+ or any environment file.
+Rails makes use of Ruby's standard `logger` to write log information. You can also substitute another logger such as `Log4R` if you wish.
+
+You can specify an alternative logger in your +environment.rb+ or any environment file:
 
 [source, ruby]
 ----------------------------------------------------------------------------
@@ -112,7 +117,7 @@ ActiveRecord::Base.logger = Logger.new(STDOUT)
 ActiveRecord::Base.logger = Log4r::Logger.new("Application Log")
 ----------------------------------------------------------------------------
 
-Or in the `__Initializer__` section, add _any_ of the following
+Or in the +Initializer+ section, add _any_ of the following
 
 [source, ruby]
 ----------------------------------------------------------------------------
@@ -125,9 +130,9 @@ By default, each log is created under `RAILS_ROOT/log/` and the log file name is
 
 === Log Levels
 
-When something is logged it's printed into the corresponding log if the message log level is equal or higher than the configured log level. If you want to know the current log level just call `ActiveRecord::Base.logger.level` method.
+When something is logged it's printed into the corresponding log if the log level of the message is equal or higher than the configured log level. If you want to know the current log level you can call the `ActiveRecord::Base.logger.level` method.
 
-The available log levels are: +:debug+, +:info+, +:warn+, +:error+, +:fatal+, each level has a log level number from 0 up to 4 respectively. To change the default log level, use
+The available log levels are: +:debug+, +:info+, +:warn+, +:error+, and +:fatal+, corresponding to the log level numbers from 0 up to 4 respectively. To change the default log level, use
 
 [source, ruby]
 ----------------------------------------------------------------------------
@@ -138,7 +143,7 @@ ActiveRecord::Base.logger.level = 0 # at any time
 This is useful when you want to log under development or staging, but you don't want to flood your production log with unnecessary information.
 
 [TIP]
-Rails default log level is +info+ in production mode and +debug+ in development and test mode.
+The default Rails log level is +info+ in production mode and +debug+ in development and test mode.
 
 === Sending Messages
 
@@ -151,7 +156,7 @@ logger.info "Processing the request..."
 logger.fatal "Terminating application, raised unrecoverable error!!!"
 ----------------------------------------------------------------------------
 
-A common example:
+Here's an example of a method instrumented with extra logging:
 
 [source, ruby]
 ----------------------------------------------------------------------------
@@ -176,45 +181,49 @@ class PostsController < ApplicationController
 end
 ----------------------------------------------------------------------------
 
-Will be logged like this:
+Here's an example of the log generated by this method:
 
+[source, log]
 ----------------------------------------------------------------------------
 Processing PostsController#create (for 127.0.0.1 at 2008-09-08 11:52:54) [POST]
-  Session ID: BAh7BzoMY3NyZl9pZCIlMDY5MWU1M2I1ZDRjODBlMzkyMWI1OTg2NWQyNzViZjYiCmZsYXNoSUM6J0FjdGlvbkNvbnRyb2xsZXI6OkZsYXNoOjpGbGFzaEhhc2h7AAY6CkB1c2VkewA=--b18cd92fba90eacf8137e5f6b3b06c4d724596a4
-  Parameters: {"commit"=>"Create", "post"=>{"title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs!!!", "published"=>"0"}, "authenticity_token"=>"2059c1286e93402e389127b1153204e0d1e275dd", "action"=>"create", "controller"=>"posts"}
-New post: {"updated_at"=>nil, "title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs!!!", "published"=>false, "created_at"=>nil}
+  Session ID: BAh7BzoMY3NyZl9pZCIlMDY5MWU1M2I1ZDRjODBlMzkyMWI1OTg2NWQyNzViZjYiCmZsYXNoSUM6J0FjdGl
+vbkNvbnRyb2xsZXI6OkZsYXNoOjpGbGFzaEhhc2h7AAY6CkB1c2VkewA=--b18cd92fba90eacf8137e5f6b3b06c4d724596a4
+  Parameters: {"commit"=>"Create", "post"=>{"title"=>"Debugging Rails", 
+ "body"=>"I'm learning how to print in logs!!!", "published"=>"0"}, 
+ "authenticity_token"=>"2059c1286e93402e389127b1153204e0d1e275dd", "action"=>"create", "controller"=>"posts"}
+New post: {"updated_at"=>nil, "title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs!!!", 
+ "published"=>false, "created_at"=>nil}
 Post should be valid: true
-  Post Create (0.000443)   INSERT INTO "posts" ("updated_at", "title", "body", "published", "created_at") VALUES('2008-09-08 14:52:54', 'Debugging Rails', 'I''m learning how to print in logs!!!', 'f', '2008-09-08 14:52:54')
+  Post Create (0.000443)   INSERT INTO "posts" ("updated_at", "title", "body", "published", 
+ "created_at") VALUES('2008-09-08 14:52:54', 'Debugging Rails', 
+ 'I''m learning how to print in logs!!!', 'f', '2008-09-08 14:52:54')
 The post was saved and now is the user is going to be redirected...
 Redirected to #<Post:0x20af760>
 Completed in 0.01224 (81 reqs/sec) | DB: 0.00044 (3%) | 302 Found [http://localhost/posts]
 ----------------------------------------------------------------------------
 
-Notice the logged lines, now you can search for any unexpected behavior in the output.
-
-By now you should know how to use the logs in any environment. Remember to take advantage of the log levels and use them wisely, mostly in production mode.
+Adding extra logging like this makes it easy to search for unexpected or unusual behavior in your logs. If you add extra logging, be sure to make sensible use of log levels, to avoid filling your production logs with useless trivia.
 
 == Debugging with ruby-debug
 
-Many times your code may not behave as you expect, sometimes you will try to print in logs, console or view values to make a diagnostic of the problem.
+When your code is behaving in unexpected ways, you can try printing to logs or the console to diagnose the problem. Unfortunately, there are times when this sort of error tracking is not effective in finding the root cause of a problem. When you actually need to journey into your running source code, the debugger is your best companion.
 
-Unfortunately, you won't find always the answer you are looking for this way. In that case, you will need to know what's happening and adventure into Rails, in this journey the debugger will be your best companion.
-
-If you ever wanted to learn about Rails source code but you didn't know where to start, this may be the best way, just debug any request to your application and use this guide to learn how to move in the code you have written but also go deeper into Rails code.
+The debugger can also help you if you want to learn about the Rails source code but don't know where to start. Just debug any request to your application and use this guide to learn how to move from the code you have written deeper into Rails code.
 
 === Setup
 
-Ruby-debug comes as a gem so to install, just run:
+The debugger used by Rails, +ruby-debug+, comes as a gem. To install it, just run:
 
+[source, shell]
 ----------------------------------------------------------------------------
-$ sudo gem in ruby-debug
+$ sudo gem install ruby-debug
 ----------------------------------------------------------------------------
 
-In case you want to download a particular version or get the source code, refer to link:http://rubyforge.org/projects/ruby-debug/[project's page on rubyforge].
+In case you want to download a particular version or get the source code, refer to the link:http://rubyforge.org/projects/ruby-debug/[project's page on rubyforge].
 
-Rails has built-in support for ruby-debug since April 28, 2007. Inside any Rails application you can invoke the debugger by calling the `debugger` method.
+Rails has had built-in support for ruby-debug since Rails 2.0. Inside any Rails application you can invoke the debugger by calling the `debugger` method.
 
-Let's take a look at an example:
+Here's an example:
 
 [source, ruby]
 ----------------------------------------------------------------------------
@@ -228,26 +237,32 @@ end
 
 If you see the message in the console or logs:
 
+[source, log]
 ----------------------------------------------------------------------------
 ***** Debugger requested, but was not available: Start server with --debugger to enable *****
 ----------------------------------------------------------------------------
 
-Make sure you have started your web server with the option --debugger:
+Make sure you have started your web server with the option +--debugger+:
 
+[source, shell]
 ----------------------------------------------------------------------------
 ~/PathTo/rails_project$ script/server --debugger
+=> Booting Mongrel (use 'script/server webrick' to force WEBrick)
+=> Rails 2.2.0 application starting on http://0.0.0.0:3000
+=> Debugger enabled
+...
 ----------------------------------------------------------------------------
 
 [TIP]
-In development mode, you can dynamically `require \'ruby-debug\'` instead of restarting the server, in case it was started without `--debugger`.
+In development mode, you can dynamically `require \'ruby-debug\'` instead of restarting the server, if it was started without `--debugger`.
 
 In order to use Rails debugging you'll need to be running either *WEBrick* or *Mongrel*. For the moment, no alternative servers are supported.
 
 === The Shell
 
-As soon as your application calls the `debugger` method, the debugger will be started in a debugger shell inside the terminal window you've fired up your application server and you will be placed in the ruby-debug's prompt `(rdb:n)`. The _n_ is the thread number.
+As soon as your application calls the `debugger` method, the debugger will be started in a debugger shell inside the terminal window where you launched your application server, and you will be placed at ruby-debug's prompt `(rdb:n)`. The _n_ is the thread number. The prompt will also show you the next line of code that is waiting to run.
 
-If you got there by a browser request, the browser will be hanging until the debugger has finished and the trace has completely run as any normal request.
+If you got there by a browser request, the browser tab containing the request will be hung until the debugger has finished and the trace has finished processing the entire request.
 
 For example:
 
@@ -256,7 +271,7 @@ For example:
 (rdb:7)
 ----------------------------------------------------------------------------
 
-Now it's time to play and dig into our application. The first we are going to do is ask our debugger for help... so we type: `help` (You didn't see that coming, right?)
+Now it's time to play and dig into your application. A good place to start is by asking the debugger for help... so type: `help` (You didn't see that coming, right?)
 
 ----------------------------------------------------------------------------
 (rdb:7) help
@@ -272,11 +287,11 @@ continue   edit     frame   method  putl  set      tmate   where
 ----------------------------------------------------------------------------
 
 [TIP]
-To view the help menu for any command use `help <command-name>` in active debug mode. For example: _help var_
+To view the help menu for any command use `help <command-name>` in active debug mode. For example: _+help var+_
 
-The second command before we move on, is one of the most useful command: `list` (or his shorthand `l`).
+The next command to learn is one of the most useful: `list`. You can also abbreviate ruby-debug commands by supplying just enough letters to distinguish them from other commands, so you can also use +l+ for the +list+ command.
 
-This command will give us a starting point of where we are by printing 10 lines centered around the current line; the current line here is line 6 and is marked by =>.
+This command shows you where you are in the code by printing 10 lines centered around the current line; the current line in this particular case is line 6 and is marked by +=>+.
 
 ----------------------------------------------------------------------------
 (rdb:7) list
@@ -293,7 +308,7 @@ This command will give us a starting point of where we are by printing 10 lines
    10        format.xml  { render :xml => @posts }
 ----------------------------------------------------------------------------
 
-If we do it again, this time using just `l`, the next ten lines of the file will be printed out.
+If you repeat the +list+ command, this time using just `l`, the next ten lines of the file will be printed out.
 
 ----------------------------------------------------------------------------
 (rdb:7) l
@@ -310,14 +325,15 @@ If we do it again, this time using just `l`, the next ten lines of the file will
    20        format.html # show.html.erb
 ----------------------------------------------------------------------------
 
-And so on until the end of the current file, when the end of file is reached, it will start again from the beginning of the file and continue again up to the end, acting as a circular buffer.
+And so on until the end of the current file. When the end of file is reached, the +list+ command will start again from the beginning of the file and continue again up to the end, treating the file as a circular buffer.
 
 === The Context
-When we start debugging your application, we will be placed in different contexts as you go through the different parts of the stack.
 
-A context will be created when a stopping point or an event is reached. It has information about the suspended program which enable a debugger to inspect the frame stack, evaluate variables from the perspective of the debugged program, and contains information about the place the debugged program is stopped.
+When you start debugging your application, you will be placed in different contexts as you go through the different parts of the stack.
 
-At any time we can call the `backtrace` command (or alias `where`) to print the backtrace of the application, this is very helpful to know how we got where we are. If you ever wondered about how you got somewhere in your code, then `backtrace` is your answer.
+ruby-debug creates a content when a stopping point or an event is reached. The context has information about the suspended program which enables a debugger to inspect the frame stack, evaluate variables from the perspective of the debugged program, and contains information about the place where the debugged program is stopped.
+
+At any time you can call the `backtrace` command (or its alias `where`) to print the backtrace of the application. This can be very helpful to know how you got where you are. If you ever wondered about how you got somewhere in your code, then `backtrace` will supply the answer.
 
 ----------------------------------------------------------------------------
 (rdb:5) where
@@ -332,7 +348,7 @@ At any time we can call the `backtrace` command (or alias `where`) to print the
 ...
 ----------------------------------------------------------------------------
 
-You move anywhere you want in this trace using the `frame _n_` command, where _n_ is the specified frame number.
+You move anywhere you want in this trace (thus changing the context) by using the `frame _n_` command, where _n_ is the specified frame number.
 
 ----------------------------------------------------------------------------
 (rdb:5) frame 2
@@ -340,27 +356,27 @@ You move anywhere you want in this trace using the `frame _n_` command, where _n
        at line /PathTo/project/vendor/rails/actionpack/lib/action_controller/base.rb:1175
 ----------------------------------------------------------------------------
 
-The available variables are the same as if we were running the code line by line, after all, that's what debugging is.
+The available variables are the same as if you were running the code line by line. After all, that's what debugging is.
 
-Moving up and down the stack frame: You can use `up [n]` (`u` for abbreviated) and `down [n]` commands in order to change the context _n_ frames up or down the stack respectively. _n_ defaults to one.
+Moving up and down the stack frame: You can use `up [n]` (`u` for abbreviated) and `down [n]` commands in order to change the context _n_ frames up or down the stack respectively. _n_ defaults to one. Up in this case is towards higher-numbered stack frames, and down is towards lower-numbered stack frames.
 
 === Threads
 
-The debugger can list, stop, resume and switch between running threads, the command `thread` (or the abbreviated `th`) is used an allows the following options:
+The debugger can list, stop, resume and switch between running threads by using the command `thread` (or the abbreviated `th`). This command has a handful of options:
 
 * `thread` shows the current thread.
-* `thread list` command is used to list all threads and their statuses. The plus + character and the number indicates the current thread of execution.
+* `thread list` is used to list all threads and their statuses. The plus + character and the number indicates the current thread of execution.
 * `thread stop _n_` stop thread _n_.
-* `thread resume _n_` resume thread _n_.
-* `thread switch _n_` switch thread context to _n_.
+* `thread resume _n_` resumes thread _n_.
+* `thread switch _n_` switches the current thread context to _n_.
 
 This command is very helpful, among other occasions, when you are debugging concurrent threads and need to verify that there are no race conditions in your code.
 
 === Inspecting Variables
 
-Any expression can be evaluated in the current context, just type it!
+Any expression can be evaluated in the current context. To evaluate an expression, just type it!
 
-In the following example we will print the instance_variables defined within the current context.
+This example shows how you can print the instance_variables defined within the current context:
 
 ----------------------------------------------------------------------------
 @posts = Post.find(:all)
@@ -368,7 +384,7 @@ In the following example we will print the instance_variables defined within the
 ["@_response", "@action_name", "@url", "@_session", "@_cookies", "@performed_render", "@_flash", "@template", "@_params", "@before_filter_chain_aborted", "@request_origin", "@_headers", "@performed_redirect", "@_request"]
 ----------------------------------------------------------------------------
 
-As you may have figured out, all variables that you can access from a controller are displayed, lets run the next line, we will use `next` (we will get later into this command).
+As you may have figured out, all of the variables that you can access from a controller are displayed. This list is dynamically updated as you execute code. For example, run the next line using `next` (you'll learn more about this command later in this guide).
 
 ----------------------------------------------------------------------------
 (rdb:11) next
@@ -379,19 +395,19 @@ Processing PostsController#index (for 127.0.0.1 at 2008-09-04 19:51:34) [GET]
 respond_to do |format|
 -------------------------------------------------------------------------------
 
-And we'll ask again for the instance_variables.
+And then ask again for the instance_variables:
 
 ----------------------------------------------------------------------------
 (rdb:11) instance_variables.include? "@posts"
 true
 ----------------------------------------------------------------------------
 
-Now +@posts+ is a included in them, because the line defining it was executed.
+Now +@posts+ is a included in the instance variables, because the line defining it was executed.
 
 [TIP]
-You can also step into *irb* mode with the command `irb` (of course!). This way an irb session will be started within the context you invoked it. But you must know that this is an experimental feature.
+You can also step into *irb* mode with the command `irb` (of course!). This way an irb session will be started within the context you invoked it. But be warned: this is an experimental feature.
 
-To show variables and their values the `var` method is the most convenient way:
+The `var` method is the most convenient way to show variables and their values:
 
 ----------------------------------------------------------------------------
 var
@@ -401,7 +417,7 @@ var
 (rdb:1) v[ar] l[ocal]                   show local variables
 ----------------------------------------------------------------------------
 
-This is a great way for inspecting the values of the current context variables. For example:
+This is a great way to inspect the values of the current context variables. For example:
 
 ----------------------------------------------------------------------------
 (rdb:9) var local
@@ -418,16 +434,16 @@ You can also inspect for an object method this way:
 ----------------------------------------------------------------------------
 
 [TIP]
-Commands `p` (print) and `pp` (pretty print) can be used to evaluate Ruby expressions and display the value of variables to the console.
+The commands `p` (print) and `pp` (pretty print) can be used to evaluate Ruby expressions and display the value of variables to the console.
 
-We can use also `display` to start watching variables, this is a good way of tracking values of a variable while the execution goes on.
+You can use also `display` to start watching variables. This is a good way of tracking the values of a variable while the execution goes on.
 
 ----------------------------------------------------------------------------
 (rdb:1) display @recent_comments
 1: @recent_comments =
 ----------------------------------------------------------------------------
 
-The variables inside the displaying list will be printed with their values after we move in the stack. To stop displaying a variable use `undisplay _n_` where _n_ is the variable number (1 in the last example).
+The variables inside the displaying list will be printed with their values after you move in the stack. To stop displaying a variable use `undisplay _n_` where _n_ is the variable number (1 in the last example).
 
 === Step by Step
 
@@ -440,9 +456,9 @@ You can also use `step+ _n_` and `step- _n_` to move forward or backward _n_ ste
 
 You may also use `next` which is similar to step, but function or method calls that appear within the line of code are executed without stopping. As with step, you may use plus sign to move _n_ steps.
 
-The difference between `next` and `step` is that `step` stops at the next line of code executed, doing just single step, while `next` moves to the next line without descending inside methods.
+The difference between `next` and `step` is that `step` stops at the next line of code executed, doing just a single step, while `next` moves to the next line without descending inside methods.
 
-Lets run the next line in this example:
+For example, consider this block of code with an included +debugger+ statement:
 
 [source, ruby]
 ----------------------------------------------------------------------------
@@ -462,7 +478,7 @@ end
 ----------------------------------------------------------------------------
 
 [TIP]
-You can use ruby-debug while using script/console but remember to `require "ruby-debug"` before calling `debugger` method.
+You can use ruby-debug while using script/console. Just remember to `require "ruby-debug"` before calling the `debugger` method.
 
 ----------------------------------------------------------------------------
 /PathTo/project $ script/console
@@ -476,7 +492,7 @@ Loading development environment (Rails 2.1.0)
 )
 ----------------------------------------------------------------------------
 
-Now we are where we wanted to be, lets look around.
+With the code stopped, take a look around:
 
 ----------------------------------------------------------------------------
 (rdb:1) list
@@ -491,7 +507,7 @@ Now we are where we wanted to be, lets look around.
    13  end
 ----------------------------------------------------------------------------
 
-We are at the end of the line, but... was this line executed? We can inspect the instance variables.
+You are at the end of the line, but... was this line executed? You can inspect the instance variables.
 
 ----------------------------------------------------------------------------
 (rdb:1) var instance
@@ -499,7 +515,7 @@ We are at the end of the line, but... was this line executed? We can inspect the
 @attributes_cache = {}
 ----------------------------------------------------------------------------
 
-+@recent_comments+ hasn't been defined yet, so we can assure this line hasn't been executed yet, lets move on this code.
++@recent_comments+ hasn't been defined yet, so it's clear that this line hasn't been executed yet. Use the +next+ command to move on in the code:
 
 ----------------------------------------------------------------------------
 (rdb:1) next
@@ -512,15 +528,15 @@ We are at the end of the line, but... was this line executed? We can inspect the
 @recent_comments = []
 ----------------------------------------------------------------------------
 
-Now we can see how +@comments+ relationship was loaded and @recent_comments defined because the line was executed.
+Now you can see that the +@comments+ relationship was loaded and @recent_comments defined because the line was executed.
 
-In case we want deeper in the stack trace we can move single `steps` and go into Rails code, this is the best way for finding bugs in your code, or maybe in Ruby or Rails.
+If you want to go deeper into the stack trace you can move single `steps`, through your calling methods and into Rails code. This is one of the best ways to find bugs in your code, or perhaps in Ruby or Rails.
 
 === Breakpoints
 
-A breakpoint makes your application stop whenever a certain point in the program is reached and the debugger shell is invoked in that line.
+A breakpoint makes your application stop whenever a certain point in the program is reached. The debugger shell is invoked in that line.
 
-You can add breakpoints dynamically with the command `break` (or just `b`), there are 3 possible ways of adding breakpoints manually:
+You can add breakpoints dynamically with the command `break` (or just `b`). There are 3 possible ways of adding breakpoints manually:
 
 * `break line`: set breakpoint in the _line_ in the current source file.
 * `break file:line [if expression]`: set breakpoint in the _line_ number inside the _file_. If an _expression_ is given it must evaluated to _true_ to fire up the debugger.
@@ -531,7 +547,7 @@ You can add breakpoints dynamically with the command `break` (or just `b`), ther
 Breakpoint 1 file /PathTo/project/vendor/rails/actionpack/lib/action_controller/filters.rb, line 10
 ----------------------------------------------------------------------------
 
-Use `info breakpoints _n_` or `info break _n_` lo list breakpoints, is _n_ is defined it shows that breakpoints, otherwise all breakpoints are listed.
+Use `info breakpoints _n_` or `info break _n_` to list breakpoints. If you supply a number, it lists that breakpoint. Otherwise it lists all breakpoints.
 
 ----------------------------------------------------------------------------
 (rdb:5) info breakpoints
@@ -539,7 +555,7 @@ Num Enb What
   1 y   at filters.rb:10
 ----------------------------------------------------------------------------
 
-Deleting breakpoints: use the command `delete _n_` to remove the breakpoint number _n_ or all of them if _n_ is not specified.
+To delete breakpoints: use the command `delete _n_` to remove the breakpoint number _n_. If no number is specified, it deletes all breakpoints that are currently active..
 
 ----------------------------------------------------------------------------
 (rdb:5) delete 1
@@ -547,57 +563,60 @@ Deleting breakpoints: use the command `delete _n_` to remove the breakpoint numb
 No breakpoints.
 ----------------------------------------------------------------------------
 
-Enabling/Disabling breakpoints:
+You can also enable or disable breakpoints:
 
-* `enable breakpoints`: allow a list _breakpoints_ or all of them if none specified, to stop your program (this is the default state when you create a breakpoint).
+* `enable breakpoints`: allow a list _breakpoints_ or all of them if no list is specified, to stop your program. This is the default state when you create a breakpoint.
 * `disable breakpoints`: the _breakpoints_ will have no effect on your program.
 
 === Catching Exceptions
 
 The command `catch exception-name` (or just `cat exception-name`) can be used to intercept an exception of type _exception-name_ when there would otherwise be is no handler for it.
 
-To list existent catchpoints use `catch`.
+To list all active catchpoints use `catch`.
 
 === Resuming Execution
 
+There are two ways to resume execution of an application that is stopped in the debugger:
+
 * `continue` [line-specification] (or `c`): resume program execution, at the address where your script last stopped; any breakpoints set at that address are bypassed. The optional argument line-specification allows you to specify a line number to set a one-time breakpoint which is deleted when that breakpoint is reached.
-* `finish` [frame-number] (or `fin`): execute until selected stack frame returns. If no frame number is given, we run until the currently selected frame returns. The currently selected frame starts out the most-recent frame or 0 if no frame positioning (e.g up, down or frame) has been performed. If a frame number is given we run until frame frames returns.
+* `finish` [frame-number] (or `fin`): execute until the selected stack frame returns. If no frame number is given, the application run until the currently selected frame returns. The currently selected frame starts out the most-recent frame or 0 if no frame positioning (e.g up, down or frame) has been performed. If a frame number is given it will run until the specified frame returns.
 
 === Editing
 
-At any time, you may use any of this commands to edit the code you are evaluating:
+Two commands allow you to open code from the debugger into an editor:
 
 * `edit [file:line]`: edit _file_ using the editor specified by the EDITOR environment variable. A specific _line_ can also be given.
 * `tmate _n_` (abbreviated `tm`): open the current file in TextMate. It uses n-th frame if _n_ is specified.
 
 === Quitting
-To exit the debugger, use the `quit` command (abbreviated `q`), or alias `exit`.
+
+To exit the debugger, use the `quit` command (abbreviated `q`), or its alias `exit`.
 
 A simple quit tries to terminate all threads in effect. Therefore your server will be stopped and you will have to start it again.
 
 === Settings
 
-There are some settings that can be configured in ruby-debug to make it easier to debug your code, being among others useful options:
+There are some settings that can be configured in ruby-debug to make it easier to debug your code. Here are a few of the available options:
 
 * `set reload`: Reload source code when changed.
 * `set autolist`: Execute `list` command on every breakpoint.
-* `set listsize _n_`: Set number of source lines to list by default _n_.
-* `set forcestep`: Make sure `next` and `step` commands always move to a new line
+* `set listsize _n_`: Set number of source lines to list by default to _n_.
+* `set forcestep`: Make sure the `next` and `step` commands always move to a new line
 
-You can see the full list by using `help set` or `help set subcommand` to inspect any of them.
+You can see the full list by using `help set`. Use `help set _subcommand_` to learn about a particular +set+ command.
 
 [TIP]
-You can include any number of this configuration lines inside a `.rdebugrc` file in your HOME directory, and ruby-debug will read it every time it is loaded
+You can include any number of these configuration lines inside a `.rdebugrc` file in your HOME directory. ruby-debug will read this file every time it is loaded. and configure itself accordingly.
 
-The following lines are recommended to be included in `.rdebugrc`:
+Here's a good start for an `.rdebugrc`:
 
+[source, log]
 ----------------------------------------------------------------------------
 set autolist
 set forcestep
 set listsize 25
 ----------------------------------------------------------------------------
 
-
 == References
 
 * link:http://www.datanoise.com/ruby-debug[ruby-debug Homepage]
@@ -614,4 +633,5 @@ set listsize 25
 
 http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/5[Lighthouse ticket]
 
+* October 19, 2008: Copy editing pass by link:../authors.html#mgunderloy[Mike Gunderloy]
 * September 16, 2008: initial version by link:../authors.html#miloops[Emilio Tagua]