Add index terms to Chapter 15

Author: marijnh

00_intro.txt

@@ -110,12 +110,12 @@ works, it is beautiful. The art of programming is the skill of
 controlling complexity. The great program is subdued, made simple in
 its complexity.
 
-(((best practices)))Many programmers believe that this complexity is
-best managed by using only a small set of well-understood techniques
-in their programs. They have composed 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.
+(((programming style)))(((best practices)))Many programmers believe
+that this complexity is best managed by using only a small set of
+well-understood techniques in their programs. They have composed
+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
@@ -354,9 +354,9 @@ 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.
+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[]
 
@@ -368,7 +368,7 @@ endif::html_target[]
 ifdef::tex_target[]
 
 (((sandbox)))(((code sandbox)))(((running code)))Most of the example
-code in this book can be found on the book's website, at
+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.

01_values.txt

@@ -133,16 +133,16 @@ very small numbers, you can also use scientific notation by adding an
 
 That is 2.998 × 10^8^ = 299800000.
 
-(((Number type,precision of)))(((floating-point numbers)))Calculations
-with whole numbers (also called _((integer))s_) smaller than the
-aforementioned 9 quadrillion are guaranteed to always be precise.
-Unfortunately, calculations with fractional numbers are generally not.
-Just as π (pi) cannot be precisely expressed by a finite number of
-decimal digits, many numbers lose some precision when only 64 bits are
-available to store them. This is a shame, but it causes practical
-problems only in specific situations. The important thing is to be
-aware of it and treat fractional digital numbers as approximations,
-not as precise values.
+(((pi)))(((Number type,precision of)))(((floating-point
+numbers)))Calculations with whole numbers (also called _((integer))s_)
+smaller than the aforementioned 9 quadrillion are guaranteed to always
+be precise. Unfortunately, calculations with fractional numbers are
+generally not. Just as π (pi) cannot be precisely expressed by a
+finite number of decimal digits, many numbers lose some precision when
+only 64 bits are available to store them. This is a shame, but it
+causes practical problems only in specific situations. The important
+thing is to be aware of it and treat fractional digital numbers as
+approximations, not as precise values.
 
 === Arithmetic ===
 

02_program_structure.txt

@@ -995,7 +995,7 @@ 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
+(((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

04_data.txt

@@ -1050,7 +1050,7 @@ contains `cos` (cosine), `sin` (sine), and `tan` (tangent), as well as
 their inverse functions, `acos`, `asin`, and `atan`. The number π
 (pi)—or at least the closest approximation that fits in a JavaScript
 number—is available as `Math.PI`. (There is an old programming
-tradition of writing the names of constant values in all caps.)
+tradition of writing the names of ((constant)) values in all caps.)
 
 // test: no
 

06_object.txt

@@ -1069,15 +1069,15 @@ fit.
 [[exercise_vector]]
 === A vector type ===
 
-(((Vector type)))(((coordinates)))(((vector (exercise))))Write a
+(((dimensions)))(((Vector type)))(((coordinates)))(((vector (exercise))))Write a
 ((constructor)) `Vector` that represents a vector in two-dimensional
 space. It takes `x` and `y` parameters (numbers), which it should save
 to properties of the same name.
 
-Give the `Vector` prototype two methods, `plus` and `minus`, which
-take another vector as a parameter, and return a new vector that has
-the sum or difference of the two vectors’ (the one in `this` and the
-parameter) x and y values.
+(((addition)))(((subtraction)))Give the `Vector` prototype two
+methods, `plus` and `minus`, which take another vector as a parameter,
+and return a new vector that has the sum or difference of the two
+vectors’ (the one in `this` and the parameter) x and y values.
 
 Add a ((getter)) property `length` to the prototype that computes the
 length of the vector—that is, the distance of the point (x, y) from

07_elife.txt

@@ -19,17 +19,18 @@ and instead work through a program with you. Theory is indispensable
 when learning to program, but it should be accompanied by reading and
 understanding non-trivial programs.
 
-(((electronic life project)))(((ecosystem)))Our project in this
-chapter is to build a virtual ecosystem, a little world populated with
-((critter))s that move around and struggle for survival.
+(((artificial life)))(((electronic life)))(((ecosystem)))Our
+project in this chapter is to build a virtual ecosystem, a little
+world populated with ((critter))s that move around and struggle for
+survival.
 
 == Definition ==
 
-(((electronic life project)))In order to make this task manageable, we
-will radically simplify the concept of a _((world))_. Namely, a world
-will be a two-dimensional ((grid)) where each entity takes up one full
-square of the grid. On every _((turn))_, the critters all get a chance
-to take some action.
+(((dimensions)))(((electronic life)))In order to make this
+task manageable, we will radically simplify the concept of a
+_((world))_. Namely, a world will be a two-dimensional ((grid)) where
+each entity takes up one full square of the grid. On every _((turn))_,
+the critters all get a chance to take some action.
 
 (((discretization)))(((simulation)))Thus, we chop both time and space
 into units with a fixed size: squares for space and turns for time. Of
@@ -60,7 +61,7 @@ var plan =
    "############################"];
 ----
 
-The “#” characters in this plan represent walls and rocks, and the
+The “#” characters in this plan represent ((wall))s and rocks, and the
 “o” characters represent critters. The spaces, as you might have
 guessed, are empty space.
 
@@ -172,7 +173,7 @@ console.log(grid.get(new Vector(1, 1)));
 
 == A critter's programming interface ==
 
-(((record)))(((electronic life project)))(((interface)))Before we can
+(((record)))(((electronic life)))(((interface)))Before we can
 start on the `World` ((constructor)), we must get more specific about
 the ((critter)) objects that will be living inside it. I mentioned
 that the world will ask the critters what actions they want to take.
@@ -263,7 +264,7 @@ when crowded into a corner by other critters).
 
 == The world object ==
 
-(((World type)))(((electronic life project)))Now we can start on the
+(((World type)))(((electronic life)))Now we can start on the
 `World` object type. The ((constructor)) takes a plan (the array of
 strings representing the world's grid, described
 link:07_elife.html#grid[earlier]) and a _((legend))_ as arguments. A
@@ -333,7 +334,7 @@ World.prototype.toString = function() {
 };
 ----
 
-(((electronic life project)))(((constructor)))(((Wall type)))A wall is
+(((electronic life)))(((constructor)))(((Wall type)))A ((wall)) is
 a very simple object—it is only used for taking up space, and has no
 `act` method.
 
@@ -468,7 +469,7 @@ Grid.prototype.forEach = function(f, context) {
 
 == Animating life ==
 
-(((simulation)))(((electronic life project)))(((World type)))The next
+(((simulation)))(((electronic life)))(((World type)))The next
 step is to write a `turn` method for the world object that gives the
 ((critter))s a chance to act. It will go over the grid using the
 `forEach` method we just defined, looking for objects with an `act`
@@ -528,7 +529,7 @@ World.prototype.checkDestination = function(action, vector) {
 };
 ----
 
-(((View type)))(((electronic life project)))First, we simply ask the
+(((View type)))(((electronic life)))First, we simply ask the
 critter to act, passing it a view object that knows about the world
 and the critter's current position in that world (we'll define `View`
 in a link:07_elife.html#view[moment]). The `act` method returns an
@@ -607,7 +608,7 @@ in, the critters still won't be tempted to try and walk off the edges.
 
 == It moves ==
 
-(((electronic life project)))(((simulation)))We instantiated a world
+(((electronic life)))(((simulation)))We instantiated a world
 object before. Now that we've added all the necessary methods, it
 should be possible to actually make it move.
 
@@ -763,7 +764,7 @@ endif::html_target[]
 
 == A more lifelike simulation ==
 
-(((simulation)))(((electronic life project)))To make life in our world
+(((simulation)))(((electronic life)))To make life in our world
 more interesting, we will add the concepts of ((food)) and
 ((reproduction)). Each living thing in the world gets a new property,
 `energy`, which is reduced by performing actions and increased by
@@ -816,7 +817,7 @@ LifelikeWorld.prototype.letAct = function(critter, vector) {
 };
 ----
 
-(((electronic life project)))(((function,as value)))(((call
+(((electronic life)))(((function,as value)))(((call
 method)))(((this)))The new `letAct` method first checks whether an
 action was returned at all, then whether a handler function for this
 type of action exists, and finally, whether that handler returned
@@ -917,7 +918,7 @@ actionTypes.reproduce = function(critter, vector, action) {
 };
 ----
 
-(((electronic life project)))Reproducing costs twice the ((energy))
+(((electronic life)))Reproducing costs twice the ((energy))
 level of the newborn critter. So we first create a (hypothetical) baby
 using `elementFromChar` on the critter's own origin character. Once we
 have a baby, we can find its energy level and test whether the parent
@@ -929,7 +930,7 @@ require a valid (and empty) destination.
 
 == Populating the new world ==
 
-(((Plant type)))(((electronic life project)))We now have a
+(((Plant type)))(((electronic life)))We now have a
 ((framework)) to simulate these more lifelike creatures. We could put
 the critters from the old world into it, but they would just die,
 since they don't have an ((energy)) property. So let us make new ones.
@@ -987,7 +988,7 @@ creature will look for when it searches for ((food)).
 
 == Bringing it to life ==
 
-(((electronic life project)))And that gives us enough elements to try
+(((electronic life)))And that gives us enough elements to try
 our new world. Imagine the map below as a grassy valley with a herd of
 ((herbivore))s in it, some boulders, and lush ((plant)) life
 everywhere.

08_error.txt

@@ -263,11 +263,12 @@ console.log(numberToString(13, 10));
 moment that you don't. We know that our program is malfunctioning, and
 we want to find out why.
 
-This is where you must resist the urge to start making random changes
-to the code. Instead, _think_. Analyze what is happening and come up
-with a ((theory)) of why it might be happening. Then, make additional
-observations to test this theory—or, if you don't yet have a theory,
-make additional observations that might help you come up with one.
+(((trial-and-error)))This is where you must resist the urge to start
+making random changes to the code. Instead, _think_. Analyze what is
+happening and come up with a ((theory)) of why it might be happening.
+Then, make additional observations to test this theory—or, if you
+don't yet have a theory, make additional observations that might help
+you come up with one.
 
 (((console.log)))(((output)))(((debugging)))(((logging)))Putting a few
 strategic `console.log` calls into the program is a good way to get
@@ -804,8 +805,8 @@ var box = {
 };
 ----
 
-(((private property)))(((access control)))It is a box, with a lock.
-Inside is an array, but you can only get at it when the box is
+(((private property)))(((access control)))It is a ((box)), with a
+lock. Inside is an array, but you can only get at it when the box is
 unlocked. Directly accessing the `_content` property is not allowed.
 
 (((finally keyword)))(((exception handling)))Write a function called

09_regexp.txt

@@ -7,8 +7,9 @@
 [chapterquote="true"]
 [quote,Jamie Zawinski]
 ____
-Some people, when confronted with a problem, think ‘I know, I'll use
-regular expressions.’ Now they have two problems.
+(((Zawinski+++,+++ Jamie)))Some people, when confronted with a
+problem, think ‘I know, I'll use regular expressions.’ Now they have
+two problems.
 ____
 
 ifdef::html_target[]
@@ -23,11 +24,11 @@ ____
 
 endif::html_target[]
 
-Programming tools and techniques survive and spread
-in a chaotic, evolutionary way. It's not always the pretty or
-brilliant ones that win, but rather the ones that function
-well enough within the right niche—for example by being
-integrated with another successful piece of technology.
+(((evolution)))Programming ((tool))s and techniques survive and spread in a chaotic,
+evolutionary way. It's not always the pretty or brilliant ones that
+win, but rather the ones that function well enough within the right
+niche—for example by being integrated with another successful piece of
+technology.
 
 In this chapter I will discuss one such tool, _regular expressions_.
 Regular expressions are a way to describe patterns in string data.