CFRCE
diff --git a/‎00_intro.txt‎
Lines changed: 24 additions & 25 deletions b/‎00_intro.txt‎
Lines changed: 24 additions & 25 deletions
diff --git a/‎01_values.txt‎
Lines changed: 35 additions & 32 deletions b/‎01_values.txt‎
Lines changed: 35 additions & 32 deletions
diff --git a/‎02_program_structure.txt‎
Lines changed: 29 additions & 29 deletions b/‎02_program_structure.txt‎
Lines changed: 29 additions & 29 deletions
@@ -18,13 +18,12 @@ appeal to our sense of the physical world, and build interfaces that
 mimic that world, and allow us to manipulate shapes on a screen with
 our fingers. This works very well for casual machine interaction.
 
-(((programming language)))(((machine language)))But we have not yet
-found a good way to use the point-and-click approach to communicate
-things to the computer that the designer of the interface did not
-anticipate. For open-ended interfaces, such as instructing the
-computer to perform arbitrary tasks, we've had more luck with an
-approach that makes use of our talent for language: teaching the
-machine a language.
+(((programming language)))But we have not yet found a good way to use
+the point-and-click approach to communicate things to the computer
+that the designer of the interface did not anticipate. For open-ended
+interfaces, such as instructing the computer to perform arbitrary
+tasks, we've had more luck with an approach that makes use of our
+talent for language: teaching the machine a language.
 
 (((human language)))(((expressivity)))Human languages allow words and
 subsentences to be combined in many, many ways, allowing us to say
@@ -133,9 +132,9 @@ their craft.
 
 == Why language matters ==
 
-(((programming language)))(((binary)))In the beginning, at the birth
-of computing, there were no programming languages. Programs looked
-something like this:
+(((programming language)))(((machine code)))(((binary data)))In the
+beginning, at the birth of computing, there were no programming
+languages. Programs looked something like this:
 
 ----
 00110001 00000000 00000000
@@ -263,19 +262,19 @@ one is almost English: `log` the `sum` of the `range` of numbers from
 1 to 10. (We will see in link:04_data.html#data[later chapters] how to
 build things like `sum` and `range`.)
 
-(((programming language,power of)))(((composition)))A good programming
-language helps the programmer by allowing them to talk about the
-actions that the computer has to perform on a higher level. It helps
-omit uninteresting details, provides convenient building blocks (such
-as `while` and `console.log`), allows you to define your own building
-blocks (such as `sum` and `range`), and makes it easy to compose these
-blocks.
+(((programming language,power of)))(((composability)))A good
+programming language helps the programmer by allowing them to talk
+about the actions that the computer has to perform on a higher level.
+It helps omit uninteresting details, provides convenient building
+blocks (such as `while` and `console.log`), allows you to define your
+own building blocks (such as `sum` and `range`), and makes it easy to
+compose these blocks.
 
 == What is JavaScript? ==
 
 indexsee:[WWW,World Wide Web] indexsee:[Web,World Wide Web]
 
-(((history)))(((Netscape Navigator)))(((browser)))(((web
+(((history)))(((Netscape)))(((browser)))(((web
 application)))(((JavaScript)))(((JavaScript,history of)))(((World Wide
 Web))) JavaScript was introduced in 1995, as a way to add programs to
 Web pages in the Netscape Navigator browser. The language has since
@@ -357,10 +356,10 @@ at first, but I promise that you will quickly get the hang of it. The
 same goes for the ((exercises)). Don't assume you understand them
 until you've actually written a working solution.
 
-I recommend to try out your solutions to exercises in an actual
-JavaScript ((interpreter)), to get immediate feedback on whether what
-you are doing is working or not, and, hopefully, to be tempted to
-((experiment)) and go beyond the exercises.
+(((interpretation)))I recommend to try out your solutions to exercises
+in an actual JavaScript interpreter, to get immediate feedback on
+whether what you are doing is working or not, and, hopefully, to be
+tempted to ((experiment)) and go beyond the exercises.
 
 ifdef::html_target[]
 
@@ -371,9 +370,9 @@ endif::html_target[]
 
 ifdef::tex_target[]
 
-(((download)))(((sandbox)))(((code sandbox)))(((running code)))Most of
-the example code in this book can be found on the book's ((website)),
-at http://eloquentjavascript.net/code[_eloquentjavascript.net/code_],
+(((download)))(((sandbox)))(((running code)))Most of the example code
+in this book can be found on the book's ((website)), at
+http://eloquentjavascript.net/code[_eloquentjavascript.net/code_],
 which also provides an easy way to run the programs and experiment
 with writing your own code.
 
 
@@ -5,17 +5,19 @@
 
 = Values, Types, and Operators =
 
+[chapterquote="true"]
 [quote, Master Yuan-Ma, The Book of Programming]
 ____
-(((Yuan-Ma)))(((Book of Programming, The)))Below the surface of the
+Below the surface of the
 machine, the program moves. Without effort, it expands and contracts.
 In great harmony, electrons scatter and regroup. The forms on the
 monitor are but ripples on the water. The essence stays invisibly
 below.
 ____
 
-(((binary data)))(((data)))(((bit)))(((memory)))Inside the computer's
-world, there is only data. You can read data, modify data, create new
+(((Yuan-Ma)))(((Book of Programming)))(((binary
+data)))(((data)))(((bit)))(((memory)))Inside the computer's world,
+there is only data. You can read data, modify data, create new
 data—but anything that isn't data simply does not exist. All this data
 is stored as long sequences of bits and is thus fundamentally alike.
 
@@ -42,7 +44,7 @@ So that's the binary number 00001101, or 8 + 4 + 1, which equals 13.
 
 == Values ==
 
-(((memory)))(((volatile data storage)))(((hard disk)))Imagine a sea of
+(((memory)))(((volatile data storage)))(((hard drive)))Imagine a sea of
 bits. An ocean of them. A typical modern computer has more than 30
 billion bits in its volatile data storage. Nonvolatile storage (the
 hard disk or equivalent) tends to have yet a few orders of magnitude
@@ -105,7 +107,7 @@ computers have plenty of memory, so you are free to use 64-bit chunks,
 which means you need to worry about overflow only when dealing with
 truly astronomical numbers.
 
-(((floating-point number)))(((fractional numbers)))(((sign bit)))Not
+(((sign)))(((floating-point number)))(((fractional number)))(((sign bit)))Not
 all whole numbers below 18 quintillion fit in a JavaScript number,
 though. Those bits also store negative numbers, so one bit indicates
 the sign of the number. A bigger issue is that nonwhole numbers must
@@ -158,11 +160,11 @@ number from them. Here is what they look like in JavaScript:
 100 + 4 * 11
 ----
 
-(((asterisk)))(((plus character)))(((pass:[*] operator)))(((+
-operator)))The `+` and `*` symbols are called _operators_. The first
-stands for addition, and the second stands for multiplication. Putting
-an operator between two values will (((application,of
-operators)))apply it to those values and produce a new value.
+(((operator,application)))(((asterisk)))(((plus
+character)))(((pass:[*] operator)))(((+ operator)))The `+` and `*`
+symbols are called _operators_. The first stands for addition, and the
+second stands for multiplication. Putting an operator between two
+values will apply it to those values and produce a new value.
 
 (((grouping)))(((parentheses)))(((precedence)))Does the example mean
 “add 4 and 100, and multiply the result by 11”, or is the
@@ -220,8 +222,7 @@ numeric operations that don't yield a precise, meaningful result.
 
 == Strings ==
 
-(((syntax)))(((textual
-data)))(((character)))(((string,notation)))(((single-quote
+(((syntax)))(((text)))(((character)))(((string,notation)))(((single-quote
 character)))(((double-quote character)))(((quotation mark)))The next
 basic data type is the _((string))_. Strings are used to represent
 text. They are written by enclosing their content in quotes.
@@ -242,9 +243,9 @@ quotes between quotes might be hard. _Newlines_ (the characters you
 get when you press Enter) also can't be put between quotes. The string
 has to stay on a single line.
 
-(((escaping,in strings)))(((backslash)))To be able to have such
-characters in a string, the following notation is used: whenever a
-backslash (“\”) is found inside quoted text, it indicates that the
+(((escaping,in strings)))(((backslash character)))To be able to have
+such characters in a string, the following notation is used: whenever
+a backslash (“\”) is found inside quoted text, it indicates that the
 character after it has a special meaning. This is called _escaping_
 the character. A quote that is preceded by a backslash will not end
 the string but be part of it. When an “n” character occurs after a
@@ -442,11 +443,11 @@ necessary:
 1 + 1 == 2 && 10 * 10 > 50
 ----
 
-(((ternary operator)))(((?: operator)))(((conditional
-operator)))(((colon character)))(((question mark)))The last logical
-operator I will discuss is not unary, not binary, but _ternary_,
-operating on three values. It is written with a question mark and a
-colon, like this:
+(((conditional execution)))(((ternary operator)))(((?:
+operator)))(((conditional operator)))(((colon character)))(((question
+mark)))The last logical operator I will discuss is not unary, not
+binary, but _ternary_, operating on three values. It is written with a
+question mark and a colon, like this:
 
 [source,javascript]
 ----
@@ -480,7 +481,7 @@ recommend treating them as interchangeable (more on that in a moment).
 
 == Automatic type conversion ==
 
-(((NaN)))(((type conversion)))In the introduction, I mentioned that
+(((NaN)))(((type coercion)))In the introduction, I mentioned that
 JavaScript goes out of its way to accept almost any program you give
 it, even programs that do odd things. This is nicely demonstrated by
 the following expressions:
@@ -509,11 +510,12 @@ to number). Yet in the third expression, `+` tries string
 concatenation before numeric addition, so the `1` is converted to
 `"1"` (from number to string).
 
-When something that doesn't map to a number in an obvious way (such as
-`"five"` or `undefined`) is converted to a number, the value `NaN` is
-produced. Further arithmetic operations on `NaN` keep producing
-`NaN`, so if you find yourself getting one of those in an unexpected
-place, look for accidental type conversions.
+(((type coercion)))(((number,conversion to)))When something that
+doesn't map to a number in an obvious way (such as `"five"` or
+`undefined`) is converted to a number, the value `NaN` is produced.
+Further arithmetic operations on `NaN` keep producing `NaN`, so if you
+find yourself getting one of those in an unexpected place, look for
+accidental type conversions.
 
 (((null)))(((undefined)))(((comparison,of undefined values)))(((==
 operator)))When comparing values of the same type using `==`, the
@@ -537,7 +539,7 @@ That last piece of behavior is often useful. When you want to test
 whether a value has a real value instead of `null` or `undefined`, you
 can simply compare it to `null` with the `==` (or `!=`) operator.
 
-(((Boolean,conversion to)))(((=== operator)))(((!==
+(((type coercion)))(((Boolean,conversion to)))(((=== operator)))(((!==
 operator)))(((comparison)))But what if you want to test whether
 something refers to the precise value `false`? The rules for
 converting strings and numbers to Boolean values state that `0`,
@@ -556,11 +558,12 @@ using the shorter operators.
 
 === Short-circuiting of logical operators ===
 
-(((operator)))The logical operators `&&` and `||` handle values of
-different types in a peculiar way. They will convert the value on
-their left side to Boolean type in order to decide what to do, but
-depending on the operator and the result of that conversion, they
-return either the _original_ left-hand value or the right-hand value.
+(((type coercion)))(((Boolean,conversion to)))(((operator)))The
+logical operators `&&` and `||` handle values of different types in a
+peculiar way. They will convert the value on their left side to
+Boolean type in order to decide what to do, but depending on the
+operator and the result of that conversion, they return either the
+_original_ left-hand value or the right-hand value.
 
 (((|| operator)))The `||` operator, for example, will return the value
 to its left when that can be converted to true and will return the
 
@@ -7,16 +7,17 @@
 [chapterquote="true"]
 [quote, _why, Why's (Poignant) Guide to Ruby]
 ____
-(((why)))(((Poignant Guide)))And my heart glows bright red under my
+And my heart glows bright red under my
 filmy, translucent skin and they have to administer 10cc of JavaScript
 to get me to come back. (I respond well to toxins in the blood.) Man,
 that stuff will kick the peaches right out your gills!
 ____
 
-In this chapter, we will start to do things that can actually be
-called _programming_. We will expand our command of the JavaScript
-language beyond the nouns and sentence fragments we've seen so far,
-to the point where we can actually express some meaningful prose.
+(((why)))(((Poignant Guide)))In this chapter, we will start to do
+things that can actually be called _programming_. We will expand our
+command of the JavaScript language beyond the nouns and sentence
+fragments we've seen so far, to the point where we can actually
+express some meaningful prose.
 
 == Expressions and statements ==
 
@@ -171,10 +172,10 @@ console.log(one + two);
 == Keywords and reserved words ==
 
 (((syntax)))(((implements (reserved word))))(((interface (reserved
-word))))(((let reserved word)))(((package (reserved word))))(((private
-reserved word)))(((protected (reserved word))))(((public reserved
-words)))(((static (reserved word))))(((void operator)))(((yield
-(reserved word))))(((reserved words)))(((variable,naming)))Words with
+word))))(((let keyword)))(((package (reserved word))))(((private
+(reserved word))))(((protected (reserved word))))(((public (reserved
+word))))(((static (reserved word))))(((void operator)))(((yield
+(reserved word))))(((reserved word)))(((variable,naming)))Words with
 a special meaning, such as `var`, are _((keyword))s_, and they may not
 be used as variable names. There are also a number of words that are
 “reserved for use” in ((future)) versions of JavaScript. These are also
@@ -211,13 +212,13 @@ indexsee:[application (of functions),function application]
 indexsee:[invoking (of functions),function application]
 indexsee:[calling (of functions),function application]
 
-(((output)))(((function)))(((function,application)))(((Function
-type)))(((alert function)))(((message box)))A lot of the values
-provided in the default environment have the type _((function))_. A
-function is a piece of program wrapped in a value. Such values can be
-_applied_ in order to run the wrapped program. For example, in a
-((browser)) environment, the variable `alert` holds a function that
-shows a little ((dialog box)) with a message. It is used like this:
+(((output)))(((function)))(((function,application)))(((alert
+function)))(((message box)))A lot of the values provided in the
+default environment have the type _((function))_. A function is a
+piece of program wrapped in a value. Such values can be _applied_ in
+order to run the wrapped program. For example, in a ((browser))
+environment, the variable `alert` holds a function that shows a little
+((dialog box)) with a message. It is used like this:
 
 [source,javascript]
 ----
@@ -226,7 +227,7 @@ alert("Good morning!");
 
 image::img/alert.png[alt="An alert dialog",width="8cm"]
 
-(((parameters)))(((function,application)))Executing a function is
+(((parameter)))(((function,application)))Executing a function is
 called _invoking_, _calling_, or _applying_ it. You can call a
 function by putting ((parentheses)) after an expression that produces a
 function value. Usually you'll directly use the name of a variable
@@ -267,8 +268,6 @@ console.log("the value of x is", x);
 // → the value of x is 30
 ----
 
-indexsee:[field,property]
-
 (((object)))Though ((variable)) names cannot contain ((period
 character))s, `console.log` clearly has one. This is because
 `console.log` isn't a simple variable. It is actually an expression
@@ -357,12 +356,13 @@ alert("Your number is the square root of " +
       theNumber * theNumber);
 ----
 
-(((type conversion)))(((Number function)))(((String
-function)))(((Boolean function)))(((Boolean type,conversion to)))The
-function `Number` converts a value to a number. We need that
-conversion because the result of `prompt` is a string value, and we
-want a number. There are similar functions called `String` and
-`Boolean` that convert values to those types.
+(((number,conversion to)))(((type coercion)))(((Number
+function)))(((String function)))(((Boolean
+function)))(((Boolean,conversion to)))The function `Number` converts a
+value to a number. We need that conversion because the result of
+`prompt` is a string value, and we want a number. There are similar
+functions called `String` and `Boolean` that convert values to those
+types.
 
 Here is the rather trivial schematic representation of straight
 control flow:
@@ -562,7 +562,7 @@ except `""` convert to `true`.
 
 == Indenting Code ==
 
-(((block)))(((code,structure of)))(((whitespace)))(((programming
+(((block)))(((code structure)))(((whitespace)))(((programming
 style)))You've probably noticed the spaces I put in front of some
 statements. In JavaScript, these are not required—the computer will
 accept the program just fine without them. In fact, even the ((line))
@@ -646,7 +646,7 @@ console.log(current);
 // → 21
 ----
 
-(((remainder operation)))(((% operator)))The trick with the remainder
+(((remainder operator)))(((% operator)))The trick with the remainder
 (`%`) operator is an easy way to test whether a number is divisible by
 another number. If it is, the remainder of their division is zero.
 
@@ -713,7 +713,7 @@ for (var number = 0; number <= 12; number += 2)
 
 == Dispatching on a value with switch ==
 
-(((syntax)))(((conditional execution)))(((dispatch)))(((if
+(((syntax)))(((conditional execution)))(((dispatching)))(((if
 keyword,chaining)))It is common for code to look like this:
 
 // test: no
@@ -1004,7 +1004,7 @@ order in which we build up the string (line by line, left to right,
 top to bottom). So the outer loop handles the lines and the inner loop
 handles the characters on a line.
 
-(((counter variable)))(((remainder operation)))(((% operator)))You'll
+(((counter variable)))(((remainder operator)))(((% operator)))You'll
 need two variables to track your progress. To know whether to put a
 space or a hash sign at a given position, you could test whether the
 sum of the two counters is even (`% 2`).