coderhs
diff --git a/‎en/documentation/faq/1/index.md
+20-18 b/‎en/documentation/faq/1/index.md
+20-18
diff --git a/‎en/documentation/faq/10/index.md
+23-21 b/‎en/documentation/faq/10/index.md
+23-21
diff --git a/‎en/documentation/faq/11/index.md
+13-15 b/‎en/documentation/faq/11/index.md
+13-15
diff --git a/‎en/documentation/faq/2/index.md
+22-21 b/‎en/documentation/faq/2/index.md
+22-21
@@ -66,7 +66,7 @@ Ruby features:
 
 ### Show me some Ruby code!
 
-Let's define a class called Person, with a name and an age. We'll test our
+Let's define a class called `Person`, with a name and an age. We'll test our
 code by creating a few people and examining them.
 
 ~~~
@@ -100,8 +100,8 @@ zoe:     7
 ~~~
 
 The code uses regular expressions to parse successive lines from the input
-file, creating a new Person object for each match and pushing it on to the
-end of the array people.
+file, creating a new `Person` object for each match and pushing it on to the
+end of the array `people`.
 
 ~~~
 people = Array.new
@@ -122,7 +122,7 @@ sorted = people.sort do |a,b| a.age <=> b.age end
 sorted           # => [elmo (4), zoe (7), bert (8), ernie (8), cookie (11)]
 ~~~
 
-Another way would be to change the comparison method for class Person:
+Another way would be to change the comparison method for class `Person`:
 
 ~~~
 class Person
@@ -195,8 +195,8 @@ the last four in Japanese:
 ~~~
 ruby-talk: English language discussion of Ruby.
 ruby-list: Japanese language discussion of Ruby.
-ruby-dev: List for Ruby developers.
-ruby-ext: List for people writing extensions for or with Ruby.
+ruby-dev:  List for Ruby developers.
+ruby-ext:  List for people writing extensions for or with Ruby.
 ruby-math: Ruby in mathematics.
 ~~~
 
@@ -221,9 +221,9 @@ set reply_regexp="^(\[[a-z0-9:-]+\][[:space:]]*)?(re([\[0-9\]+])*|aw):[[:space:]
 ### Which is correct, “Ruby” or “ruby”?
 
 Officially, the language is called “Ruby”. On most systems, it is invoked
-using the command `ruby`. It's OK to use ruby instead of Ruby.
+using the command `ruby`. It's OK to use “ruby” instead of “Ruby”.
 
-Please don't use RUBY as the language name.
+Please don't use “RUBY” as the language name.
 
 Originally, or historically, it was called “ruby”.
 
@@ -250,17 +250,17 @@ expressions.
 
 ### Which editors provide support for Ruby?
 
-* Emacs or XEmacs: ruby-mode.el is supplied in the Ruby distribution.
-  With some versions of XEmacs, you may need to add (load "font-lock") to your
-  .emacs file to allow ruby-mode.el to detect the syntax highlighting package
-  you're using.
+* Emacs or XEmacs: `ruby-mode.el` is supplied in the Ruby distribution.
+  With some versions of XEmacs, you may need to add `(load "font-lock")`
+  to your `.emacs` file to allow `ruby-mode.el` to detect the syntax
+  highlighting package you're using.
 * Vim: Vim 5.7 and later have Ruby syntax files as standard in the runtime
   package. For prior versions, a syntax file for Ruby is available at
   http://www.xs4all.nl/~hipster/lib/ruby/ruby.vim.
 * Jedit: A portable editor written in Java, comes with support for Ruby.
 * Jed: An s-lang file supporting Ruby is available at
   http://www.kondara.org/~g/slang/ruby.sl.
-* Nedit ( http://www.nedit.org): Eric Santonacci has written Ruby support for
+* Nedit (http://www.nedit.org): Eric Santonacci has written Ruby support for
   Nedit, available from ftp://ftp.talc.fr/pub/ruby/ruby.nedit-0.1.tar.gz.
 * Barry Shultz has written a Ruby definition file for TextPad, available at
   http://www.textpad.com/add-ons/ntsyn.html.
@@ -277,13 +277,13 @@ str = "Billy" + " Bob"           # => "Billy Bob"
 str[0,1] + str[2,1] + str[-2,2]  # => "Blob"
 ~~~
 
-Gotoken's xmp package, available from
+Gotoken's `xmp` package, available from
 http://www.ruby-lang.org/en/raa-list.rhtml?name=xmp is a utility that
 annotates Ruby source code this way.
 
 Emacs and vim users can integrate this with their editing environments, which
 is useful if you want to send people e-mail with annotated Ruby code. Having
-installed xmp, Emacs users can add the following to their .emacs file:
+installed `xmp`, Emacs users can add the following to their `.emacs` file:
 
 ~~~
 (defun ruby-xmp-region (reg-start reg-end)
@@ -315,10 +315,12 @@ mailing list). Generally you'll get timely answers from matz himself, the
 author of the language, from other gurus, and from those who've solved
 problems similar to your own.
 
-Please include the output of ruby -v along with any problematic source code.
+Please include the output of `ruby -v` along with any problematic
+source code.
 
-If you have a problem using irb, be aware that it has some limitations.
-Try the script using `irb --single-irb`, or directly using the ruby command.
+If you have a problem using `irb`, be aware that it has some limitations.
+Try the script using `irb --single-irb`, or directly using the
+`ruby` command.
 
 There might be similar questions in the mailing list, and it is good
 netiquette to read through recent mails (RFC1855:3.1.1, 3.1.2) before asking.
 
@@ -39,7 +39,7 @@ header: |
 
 ### How can I use Ruby interactively?
 
-You can try using irb. The following is paraphrased from Goto Kentaro
+You can try using `irb`. The following is paraphrased from Goto Kentaro
 (Gotoken), and originally appeared in ruby-talk:444.
 
 ~~~
@@ -52,13 +52,13 @@ Possibly use rehash to tell your login shell about the new command.
 Type irb
 ~~~
 
-If the readline extension module works with your interpreter, it makes irb
+If the readline extension module works with your interpreter, it makes `irb`
 a lot more fun to use.
 
-There is also a simple program, eval, in the samples/ directory of the Ruby
-distribution. It lets you enter expressions and view their values. You can
-copy eval into the site_ruby directory in the Ruby tree, and then invoke it
-using:
+There is also a simple program, `eval`, in the `samples/` directory of the
+Ruby distribution. It lets you enter expressions and view their values.
+You can copy `eval` into the `site_ruby` directory in the Ruby tree, and
+then invoke it using:
 
 ~~~
 ruby -r eval -e0
@@ -79,39 +79,41 @@ There are no problems with reference counting and variable types, and very
 few interfaces to learn. In fact, C code used to extend Ruby often ends up
 looking surprisingly like Ruby code itself.
 
-First, get the Ruby source distribution and read README.EXT. This is a good
-document, not only if you're writing an extension library, but also if you
-want to understand Ruby more deeply.
+First, get the Ruby source distribution and read `README.EXT`. This is a
+good document, not only if you're writing an extension library, but also
+if you want to understand Ruby more deeply.
 
 Next, have a look at the source of the interpreter itself, and at the various
-supplied extensions in the ext/ directory. You'll also find good examples
-under contrib/ on the Ruby ftp sites.
+supplied extensions in the `ext/` directory. You'll also find good examples
+under `contrib/` on the Ruby ftp sites.
 
 ### Can I use Tcl/Tk interface in Ruby?
 
 There are two interfaces to Tcl/Tk included in the standard distribution.
-One is under ext/tcltk/ and loaded with require "tcltk". The syntax is very
-close to that Tcl, which is passed to Tcl interpreter. Unfortunately, the
-description for this library is written in Japanese.
+One is under `ext/tcltk/` and loaded with `require "tcltk"`. The syntax is
+very close to that Tcl, which is passed to Tcl interpreter.
+Unfortunately, the description for this library is written in Japanese.
 
-The other is under ext/tk/ and loaded with require "tk". Its syntax closer to
-the style of the Tk interface provided by the Perl and Python interfaces.
+The other is under `ext/tk/` and loaded with `require "tk"`. Its syntax
+closer to the style of the Tk interface provided by the Perl and Python
+interfaces.
 
 ### Tk won't work.
 
 Your Tk version may be old, try a newer version.
 
 ### Can I use gtk+ or xforms interfaces in Ruby?
 
-You'll find ruby-gtk-x.xx.tar.gz and ruby-forms-x.x.tar.gz under contrib/
+You'll find ruby-gtk-x.xx.tar.gz and ruby-forms-x.x.tar.gz under `contrib/`
 in ftp sites.
 
 ### How can I do date arithmetic?
 
-A Time object can express only the dates between Jan 1, 1970 and Jan 19, 2038.
+A `Time` object can express only the dates between Jan 1, 1970 and
+Jan 19, 2038.
 
 Two standard extension library modules are provided:
-require "date", which is simple and uses the English calendar,
-and require "date2", which is more general purpose.
+`require "date"`, which is simple and uses the English calendar,
+and `require "date2"`, which is more general purpose.
 
-Also see sample/cal.rb.
+Also see `sample/cal.rb`.
@@ -37,9 +37,9 @@ header: |
 
 ## Other features
 
-### What does a ? b : c mean?
+### What does `a ? b : c` mean?
 
-It's the same as saying if a then b else c end.
+It's the same as saying `if a then b else c` end.
 
 ### How can I count the number of lines in a file?
 
@@ -50,17 +50,17 @@ fastest result.
 open("example").read.count("\n")  # => 3
 ~~~
 
-### What do begin and end of MatchingData return?
+### What do `begin` and `end` of `MatchingData` return?
 
-They act with $ , and return the start index and the end index of the
-matched data ($0) in the original string. See an example in tab expansion.
+They act with `$ `, and return the start index and the end index of the
+matched data (`$0`) in the original string. See an example in tab expansion.
 
 ### How can I sum the elements in an array?
 
 Rather than solve the specific problem, let's solve the general case. The
-first thing we'll do is produce a method that will iterate over an Enumerable
-object and collect a single result. Smalltalk calls that method inject, so we
-will too:
+first thing we'll do is produce a method that will iterate over an
+`Enumerable` object and collect a single result. Smalltalk calls that
+method inject, so we will too:
 
 ~~~
 module Enumerable
@@ -75,11 +75,11 @@ module Enumerable
 end
 ~~~
 
-Notice how we've added the method to Enumerable. This means that anything
-that includes Enumerable can now use inject. But how do we use it? It takes
-a single argument `n' and a block. For each element in the thing being
-enumerated, it calls the block, passing in `n' and the element itself.
-The result of the block is assigned back to `n'. So, to define sum,
+Notice how we've added the method to `Enumerable`. This means that anything
+that includes Enumerable can now use `inject`. But how do we use it? It takes
+a single argument `n` and a block. For each element in the thing being
+enumerated, it calls the block, passing in `n` and the element itself.
+The result of the block is assigned back to `n`. So, to define `sum`,
 we could write:
 
 ~~~
@@ -133,7 +133,6 @@ end
 ~~~
 
 
-
 ~~~
 # --------------------------------------------------------------------
 # Filtering Out Multiples of a Given Number
@@ -160,7 +159,6 @@ end
 ~~~
 
 
-
 ~~~
 # --------------------------------------------------------------------
 # Prime Number Generator
 
@@ -54,21 +54,21 @@ of every method def. When a function is inserted into an object, the first
 argument automagically becomes a reference to the receiver.
 
 Ruby is a pure OO language that can masquerade as a procedural one. It has no
-functions, only method calls. In a Ruby method the receiver, also called `self`,
-is a hidden argument like `this` in C++. A `def` statement outside of a
-class definition, which is a function in Python, is actually a method call in
-Ruby. These ersatz functions become private methods of class Object, the root
-of the Ruby class hierarchy. Procedural programming is neatly solved from the
-other direction - everything is an object. If the user doesn't grok objects
-yet, they can just pretend that `def` is a function definition and still
-get useful work done.
+functions, only method calls. In a Ruby method the receiver, also called
+`self`, is a hidden argument like `this` in C++. A `def` statement outside of
+a class definition, which is a function in Python, is actually a method call
+in Ruby. These ersatz functions become private methods of class Object, the
+root of the Ruby class hierarchy. Procedural programming is neatly solved from
+the other direction - everything is an object. If the user doesn't grok
+objects yet, they can just pretend that `def` is a function definition and
+still get useful work done.
 
 Ruby's OO purity provides a number features that Python lacks or is still
 working toward: a unified type/class hierarchy, metaclasses, the ability to
-subclass everything, and uniform method invocation (none of this len() is a
-function but items() is a method rubbish). Ruby, like Smalltalk, only supports
-single inheritance, but it does have a very powerful mixin concept: a class
-definition may include a module, which inserts that module's methods,
+subclass everything, and uniform method invocation (none of this `len()` is a
+function but `items()` is a method rubbish). Ruby, like Smalltalk, only
+supports single inheritance, but it does have a very powerful mixin concept:
+a class definition may include a module, which inserts that module's methods,
 constants, etc. into the class.
 
 Ruby, again like Smalltalk, provides closures and code blocks and uses them
@@ -77,14 +77,15 @@ outstanding, much more powerful and elegant than the ad hoc solutions that
 Python is sprouting (lambdas and list comprehensions).
 
 Ruby's syntax and design philosophy are heavily influenced by Perl. It has a
-lot of syntactic variability. Statement modifiers (if, unless, while, until,
-etc.) may appear at the end of any statement. Some key words are optional
-(the `then` in an `if` statement for example). Parentheses may sometimes
-be elided in method calls. The receiver of a method may usually be elided.
+lot of syntactic variability. Statement modifiers (`if`, `unless`, `while`,
+`until`, etc.) may appear at the end of any statement. Some key words are
+optional (the `then` in an `if` statement for example). Parentheses may
+sometimes be elided in method calls. The receiver of a method may usually be
+elided.
 Many, many things are lifted directly from Perl.
-Built in regular expressions, $_ and friends, here documents,
-the single-quoted / double-quoted string distinction, $ and @ prefixes
-to distinguish different kinds of names and so forth.
+Built in regular expressions, `$_` and friends, here documents, the
+single-quoted / double-quoted string distinction, `$` and `@` prefixes to
+distinguish different kinds of names and so forth.
 
 If you like Perl, you will like Ruby and be right at home with its syntax.
 If you like Smalltalk, you will like Ruby and be right at home with its
@@ -97,5 +98,5 @@ mined for P3K. I'm not sure how many Python programmers will be attracted to
 it though - it hasn't won me over (yet). But it is worthy of serious study and
 could be a real threat to Perl.
 
-Posted by John Dell'Aquila in comp.lang.python, 11/17/2000. Reproduced with
-permission.
+Posted by John Dell'Aquila in comp.lang.python, 11/17/2000.
+Reproduced with permission.