edit intro

Author: ocha-

intro.textile

@@ -273,57 +273,67 @@ On the other hand, Ruby acceps a following expression because @if@ is an express
 result = if cond then process(val) else nil end
 </pre>
 
-Roughly, you can assume any element which can be fed as an argument for a function
-or a method is a formula. 
+Roughly speaking, if it can be an argument of a function or a method,
+you can consider it as an expression.
 
-Of course, there are other languages whose syntactic elements are mostly a formula.
-Namely, Lisp is the best example. For this characteristic, many people seem to
-regard Ruby is similar to Lisp. 
+Of course, there are other languages whose syntactic elements are mostly expressions.
+Lisp is the best example. Because of the characteristic around this,
+there seems many people who feel like "Ruby is similar to Lisp".
 
 h4. Iterators
 
 Ruby has iterators. What is an iterator? Before getting into iterators, I should
 mention the necessity of using an alternative term, because the word "iterator" is
-disliked recently. However, I don't have a good alternation. So let us keep calling
+disliked recently. However, I don't have a good alternative. So let us keep calling
 it "iterator" for the time being. 
 
-Well again, what is an iterator? If you are already familiar with a high level
-function which is similar, you can assume it for now. C-language example is the way
-you feed function pointer as an argument. C++ example is a way to envelope the
-operation part of STL's @Iterator@ into a method. If you are familiar with sh and
-Perl, you can imagine it like a custom defined @for@ statement. 
+Well again, what is an iterator? If you know higher-order function,
+for the time being, you can regard it as something similar to it.
+In C-language, the counterpart would be passing a function pointer as an argument.
+In C++, it would be a method to which the operation part of STL's @Iterator@ is enclosed.
+If you know @sh@ or @Perl@,
+it's good to imagine something like a custom @for@ statement which we can define.
 
 Yet, the above are merely examples of "similar" concepts. All of them are similar,
 but they are not identical to Ruby's iterator. I will expand the precise story
 when it's a good time later. 
 
 h4. Written in C-language
 
-Being written in C-language is not distinctive these days, but it's still a notable
-characteristic for sure. Unlike being written in Haskell or PL/I, it should possibly
-be readable for a wide range of people generally. (I want you to confirm it in the
-later in this book.) 
+Being written in C-language is not notable these days, but it's still a
+characteristic for sure.
+At least it is not written in Haskell or PL/I,
+thus there's the high possibility that the ordinary people can read it.
+(Whether it is truly so, I'd like you confirm it by yourself.)
 
 Well, I just said it's in C-language, but the actual language version which ruby is
 targetting is basically K&R C.  Until a little while ago, there were a decent number
-of - not plenty though - K&R-only-environment.  Considering the trend of ANSI C being
-a popular environment that seems to pass most of programs, there appears to be no
-problem to port to ANSI C. However, the K&R style code is still maintained, with the
-author Matsumoto's preference being one aspect. 
+of - not plenty though - K&R-only-environment.
+But recently, there are a few environments which do not accept programs
+written in ANSI C, technically there's no problem to move on to ANSI C.
+However, also because of the author Matsumoto's personal preference,
+it is still written in K&R style.
 
 For this reason, the function definition is all in K&R style, and the prototype
-declarations are not strictly written. Looking at the mailing list, I can see a lot
-of topics in which @gcc@ with @-Wall@ option outputs a huge dump of errors, and C++
-compiler warns prototype mismatch that fails to finish compiling. 
+declarations are not so seriously written.
+If you carelessly specify @-Wall@ option of @gcc@,
+there would be plenty of warnings shown.
+If you try to compile it with a C++ compiler,
+it would warn prototype mismatch and could not compile.
+... These kind of stories are often reported to the mailing list.
+
 
 h4. Extension library
 
-Ruby library can be written in C. It can be loaded at execution without recompiling Ruby.
+We can write a Ruby library in C and load it at runtime without recompiling Ruby.
 This type of library is called "Ruby extension library" or just "Extension library". 
 
-In addition to the fact that's written in C, one of the important feature is that Ruby
-level and C level code differences are very small. Most commands available in Ruby are
-also available in C. See following example. 
+Not only the fact that we can write it in C,
+but the very small difference in the code expression between Ruby-level and
+C-level is also a significant trait.
+As for the operations available in Ruby,
+we can also use them in C in the almost same way.
+See the following example.
 
 <pre class="emlist"> 
 # Method call
@@ -353,24 +363,24 @@ h4. Thread
 Ruby is equipped with thread. Assuming a very few people knowing none about thread these
 days, I will omit an explanation about the thread itself. I will start a story in detail. 
 
-The thread level of @ruby@ belongs to the user level of origin. The characteristic of
++ruby+'s thread is a user-level thread that is originally written. The characteristic of
 this implementation is a very high portability in both specification and implementation.
 Surprisingly a MS-DOS can run the thread. Furthermore, you can expect the same response
 in any environment. Many people mention that this point is the best feature of @ruby@.
 
 However, as a trade off for such an extremeness of portability, @ruby@ abandons the speed.
 It's, say, probably the slowest of all user-level thread implementations in this world.
-The trend of @ruby@ implementation may be seen here the most clearly. 
+The tendency of @ruby@ implementation may be seen here the most clearly.
 
 h2. Technique to read source code
 
 Well. After an introduction of @ruby@, we are about to start reading source code. But wait. 
 
 Any programmer has to read a source code somewhere, but I guess there are not many occasions
-that someone teaches you the concrete ways how to read. Why? Is it because writing a program
-naturally assumes reading a program? 
+that someone teaches you the concrete ways how to read. Why?
+Does it mean you can naturally read a program if you can write a program?
 
-I don't think so. It's not easy to actually read a code written by other people.
+But I can't think reading the program written by other people is so easy.
 In the same way as writing programs, there must be techniques and theories in reading programs.
 And they are necessary. Therefore, before starting to ready @ruby@, I'd like to expand a general
 summary of an approach you need to take in reading a source code. 
@@ -382,8 +392,9 @@ At first, I mention the principle.
 h4. Decide a goal
 
 
-bq. 
+<blockquote>
 An important key to reading the source code is to set a concrete goal. 
+</blockquote>
 
 
 This is a word by the author of Ruby, Matsumoto. Indeed, his word is very convincing for me.