Add index terms to Chapter 9

marijnh · marijnh · commit a83171516877 · 2014-07-25T17:53:28.000+02:00
diff --git a/00_intro.txt b/00_intro.txt
@@ -18,25 +18,27 @@ 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)))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)))Human languages allow words and subsentences to be
-combined in many, many ways, allowing us to say many, many different
-things. Computer languages, though typically less grammatically
-flexible, follow a similar principle.
-
-(((JavaScript,availability of)))(((browser)))Casual computing has
-become become much more widespread in the past twenty years, and
+(((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.
+
+(((human language)))(((expressivity)))Human languages allow words and
+subsentences to be combined in many, many ways, allowing us to say
+many, many different things. Computer languages, though typically less
+grammatically flexible, follow a similar principle.
+
+(((JavaScript,availability of)))(((casual computing)))Casual computing
+has become become much more widespread in the past twenty years, and
 language-based interfaces, which once were the default way in which
 people interacted with computers, have largely been replaced with
 graphical interfaces. But they are still there, if you know where to
 look. One such language, _JavaScript_, is built into just about every
-web browser, and thus available on just about every consumer device.
+web ((browser)), and thus available on just about every consumer
+device.
 
 indexsee:[web browser,browser]
 
@@ -61,7 +63,7 @@ clear. But programs, built on top of these basic rules, tend to become
 complex enough to introduce their own rules and complexity. You're
 building your own maze, in a way, and might just get lost in it.
 
-There will be times at which reading this book feels terribly
+(((learning)))There will be times at which reading this book feels terribly
 frustrating. If you are new to programming, there will be a lot of new
 material to digest. Much of this material will then be _combine_ in
 ways that require you to make additional connections.
@@ -117,16 +119,17 @@ strict rules (_“best practices”_) prescribing the form programs should
 have, and the more zealous among them will consider those that go
 outside of this little safe zone to be _bad_ programmers.
 
-What hostility to the richness of programming—to try to reduce it to
-something straightforward and predictable, to place a taboo on all the
-weird and beautiful programs! The landscape of programming techniques
-is enormous, fascinating in its diversity, and still largely
-unexplored. It is certainly dangerous going, luring the inexperienced
-programmer into all kinds of confusion, but that only means you should
-proceed with caution and keep your wits about you. As you learn, there
-will always be new challenges and new territory to explore.
-Programmers who refuse to keep exploring will stagnate, forget their
-joy, and get bored with their craft.
+(((experiment)))(((learning)))What hostility to the richness of
+programming—to try to reduce it to something straightforward and
+predictable, to place a taboo on all the weird and beautiful programs!
+The landscape of programming techniques is enormous, fascinating in
+its diversity, and still largely unexplored. It is certainly dangerous
+going, luring the inexperienced programmer into all kinds of
+confusion, but that only means you should proceed with caution and
+keep your wits about you. As you learn, there will always be new
+challenges and new territory to explore. Programmers who refuse to
+keep exploring will stagnate, forget their joy, and get bored with
+their craft.
 
 == Why language matters ==
 
@@ -317,22 +320,23 @@ has its advantages, though. It leaves space for a lot of techniques
 that are impossible in more rigid languages, and, as we will see, for
 example, in the link:10_modules.html#modules[chapter on modules], it
 can be used to overcome some of JavaScript's shortcomings. After
-learning the language properly and working with it for a while, I have
+((learning)) the language properly and working with it for a while, I have
 learned to actually _like_ JavaScript.
 
-(((JavaScript,versions of)))(((ECMAScript)))(((ECMAScript 6)))There
-have been several _versions_ of JavaScript. ECMAScript version 3 was
-the dominant, widely supported version in the time of JavaScript's
-ascent to dominance, roughly between 2000 and 2010. During this time,
-work was underway on an ambitious version 4, which planned a number of
-radical improvements and extensions to the language. Changing a
-living, widely used language in such a radical way turned out to be
-politically difficult, and work on the 4th edition was abandoned in
-2008, leading to the much less ambitious 5th edition coming out in
-2009. We're now at the point where all major browsers support this 5th
-edition, which is the language version that this book will be focusing
-on. A 6th edition is in the process of being finalized, and some
-browsers are starting to support new features from this edition.
+(((future)))(((JavaScript,versions of)))(((ECMAScript)))(((ECMAScript
+6)))There have been several _versions_ of JavaScript. ECMAScript
+version 3 was the dominant, widely supported version in the time of
+JavaScript's ascent to dominance, roughly between 2000 and 2010.
+During this time, work was underway on an ambitious version 4, which
+planned a number of radical improvements and extensions to the
+language. Changing a living, widely used language in such a radical
+way turned out to be politically difficult, and work on the 4th
+edition was abandoned in 2008, leading to the much less ambitious 5th
+edition coming out in 2009. We're now at the point where all major
+browsers support this 5th edition, which is the language version that
+this book will be focusing on. A 6th edition is in the process of
+being finalized, and some browsers are starting to support new
+features from this edition.
 
 (((JavaScript,uses of)))Web browsers are not the only platforms on
 which JavaScript is used. Some databases, such as MongoDB and CouchDB,
@@ -347,7 +351,7 @@ outside of the browser.
 (((reading code)))(((writing code)))Code is the text that makes up
 programs. Most chapters in this book contain quite a lot of it. In my
 experience, reading and writing ((code)) is an indispensable part of
-learning to program. Try to not just glance over the examples, read
+((learning)) to program. Try to not just glance over the examples, read
 them attentively and understand them. This will be slow and confusing
 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
diff --git a/01_values.txt b/01_values.txt
@@ -122,9 +122,10 @@ dot.
 9.81
 ----
 
-(((scientific notation)))(((Number type,notation)))For very big or
-very small numbers, you can also use scientific notation by adding an
-“e”, followed by the exponent of the number:
+(((exponent)))(((scientific notation)))(((Number type,notation)))For
+very big or very small numbers, you can also use scientific notation
+by adding an “e” (for “exponent”), followed by the exponent of the
+number:
 
 [source,javascript]
 ----
@@ -157,26 +158,27 @@ number from them. Here is what they look like in JavaScript:
 100 + 4 * 11
 ----
 
-(((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.
+(((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.
 
-(((parentheses)))(((precedence)))Does the example mean “add 4 and 100,
-and multiply the result by 11”, or is the multiplication done before
-the adding? As you might have guessed, the multiplication happens
-first. But, as in mathematics, you can change this by wrapping the
-addition in parentheses.
+(((grouping)))(((parentheses)))(((precedence)))Does the example mean
+“add 4 and 100, and multiply the result by 11”, or is the
+multiplication done before the adding? As you might have guessed, the
+multiplication happens first. But, as in mathematics, you can change
+this by wrapping the addition in parentheses.
 
 [source,javascript]
 ----
 (100 + 4) * 11
 ----
 
-(((division)))(((subtraction)))(((- operator)))(((/ operator)))For
-subtraction, there is the `-` operator, and division can be done with
-the `/` operator.
+(((dash character)))(((slash
+character)))(((division)))(((subtraction)))(((minus)))(((-
+operator)))(((/ operator)))For subtraction, there is the `-` operator,
+and division can be done with the `/` operator.
 
 When operators appear together without parentheses, the order in which
 they are applied is determined by the _((precedence))_ of the
@@ -219,7 +221,8 @@ numeric operations that don't yield a precise, meaningful result.
 == Strings ==
 
 (((syntax)))(((String type)))(((textual
-data)))(((character)))(((String type,notation)))(((quote)))The next
+data)))(((character)))(((String type,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.
 
@@ -232,12 +235,12 @@ They are written by enclosing their content in quotes.
 Both single and double quotes can be used to mark strings as long as
 the quotes at the start and the end of the string match.
 
-(((newline character)))Almost anything can be put between quotes, and
-JavaScript will make a string value out of it. But a few characters
-are more difficult. You can imagine how putting 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.
+(((line break)))(((newline character)))Almost anything can be put
+between quotes, and JavaScript will make a string value out of it. But
+a few characters are more difficult. You can imagine how putting
+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
diff --git a/02_program_structure.txt b/02_program_structure.txt
@@ -27,11 +27,12 @@ applied operators to them to get new values. Creating values like this
 is an essential part of every JavaScript program, but it is still only
 a part.
 
-A fragment of code that produces a value is called an
-_((expression))_. Every value that is written literally (such as `22`
-or `"psychoanalysis"`) is an expression. An expression between
-((parentheses)) is also an expression, as is a ((binary operator))
-applied to two expressions or a unary operator applied to one.
+(((literal expression)))A fragment of code that produces a value is
+called an _((expression))_. Every value that is written literally
+(such as `22` or `"psychoanalysis"`) is an expression. An expression
+between ((parentheses)) is also an expression, as is a ((binary
+operator)) applied to two expressions or a unary operator applied to
+one.
 
 (((nesting,of expressions)))(((human language)))This shows part of the
 beauty of a language-based interface. Expressions can nest in a way
@@ -68,7 +69,7 @@ happens.
 (((programming style)))(((automatic semicolon
 insertion)))(((semicolon)))In some cases, JavaScript allows you to
 omit the semicolon at the end of a statement. In other cases, it has
-to be there, the next line will be treated as part of the same
+to be there, the next ((line)) will be treated as part of the same
 statement. The rules for when it can be safely omitted are somewhat
 complex and error-prone. In this book, every statement that needs a
 semicolon will always be terminated by one. I recommend you do the
@@ -176,7 +177,7 @@ words)))(((static (reserved word))))(((void operator)))(((yield
 (reserved word))))(((reserved words)))(((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
+“reserved for use” in ((future)) versions of JavaScript. These are also
 officially not allowed to be used as variable names, though some
 JavaScript environments do allow them. The full list of keywords and
 reserved words is rather long.
@@ -494,10 +495,10 @@ keyword `while` creates a loop. The word `while` is followed by an
 The loop executes that statement as long as the expression produces a
 value that is `true` when converted to Boolean type.
 
-((({} (block))))(((block)))In this loop, we want to both
+(((grouping)))((({} (block))))(((block)))In this loop, we want to both
 print the current number and add two to our variable. Whenever we need
 to execute multiple ((statement))s inside a loop, we wrap them in
-((braces)) (`{` and `}`). Braces do for statements what
+((curly braces)) (`{` and `}`). Braces do for statements what
 ((parentheses)) do for expressions: they group them together, making
 them count as a single statement. A sequence of statements wrapped in
 braces is called a _block_.
@@ -564,7 +565,7 @@ except `""` convert to `true`.
 (((block)))(((code,structure of)))(((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
+accept the program just fine without them. In fact, even the ((line))
 breaks in programs are optional. You could write a program as a single
 long line if you felt like it. The role of the ((indentation)) inside
 blocks is to make the structure of the code stand out. In complex
@@ -996,11 +997,11 @@ character is written `"\n"`.
 Use `console.log` to inspect the output of your program.
 
 (((nesting,of loops)))To work with two ((dimensions)), you will need a
-((loop)) inside of a loop. Put ((braces)) around the bodies of both
-loops to make it easy to see where they start and end. Try to properly
-indent these bodies. The order of the loops must follow the 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
+((loop)) inside of a loop. Put ((curly braces)) around the bodies of
+both loops to make it easy to see where they start and end. Try to
+properly indent these bodies. The order of the loops must follow the
+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
diff --git a/03_functions.txt b/03_functions.txt
@@ -277,10 +277,10 @@ function square(x) {
 }
 ----
 
-(((execution order)))This is a function _declaration_. The statement
-defines the variable `square` and points it at the given function. So
-far so good. There is one subtlety with this form of function
-definition, however.
+(((future)))(((execution order)))This is a function _declaration_. The
+statement defines the variable `square` and points it at the given
+function. So far so good. There is one subtlety with this form of
+function definition, however.
 
 [source,javascript]
 ----
diff --git a/04_data.txt b/04_data.txt
@@ -110,12 +110,12 @@ expression that corresponds to the _((index))_ given by the expression
 in the brackets.
 
 [[array_indexing]]
-(((zero-based counting)))The first index of an array is zero, not one.
-So the first element can be read with `listOfNumbers[0]`. If you don't
-have a programming background, this convention might take some getting
-used to. But zero-based counting has a long tradition in technology,
-and as long as this convention is followed consistently (which it is,
-in JavaScript), it works well.
+The first index of an array is zero, not one. So the first element can
+be read with `listOfNumbers[0]`. If you don't have a programming
+background, this convention might take some getting used to. But
+((zero-based counting)) has a long tradition in technology, and as
+long as this convention is followed consistently (which it is, in
+JavaScript), it works well.
 
 [[properties]]
 == Properties ==
diff --git a/07_elife.txt b/07_elife.txt
@@ -391,12 +391,12 @@ inside the ((loop)). Instead, the outer function creates a normal
 local variable, `grid`, through which the inner function gets access
 to the grid.
 
-(((ECMAScript 6)))(((arrow function)))(((self variable)))This is a bit
-of a design blunder in JavaScript. Fortunately, the next version of
-the language provides a solution for this problem. Meanwhile, there
-are workarounds. A common pattern is to say `var self = this` and from
-then on refer to `self`, which is a normal variable and thus visible
-to inner functions.
+(((future)))(((ECMAScript 6)))(((arrow function)))(((self
+variable)))This is a bit of a design blunder in JavaScript.
+Fortunately, the next version of the language provides a solution for
+this problem. Meanwhile, there are workarounds. A common pattern is to
+say `var self = this` and from then on refer to `self`, which is a
+normal variable and thus visible to inner functions.
 
 (((bind method)))(((this)))Another solution is to use the `bind`
 method, which allows us to provide an explicit `this` object to bind
diff --git a/09_regexp.txt b/09_regexp.txt
diff --git a/10_modules.txt b/10_modules.txt
diff --git a/16_canvas.txt b/16_canvas.txt
