Another pass over chapter 7

marijnh · marijnh · commit be574c0a9ea8 · 2014-04-23T16:40:31.000+02:00
diff --git a/07_elife.txt b/07_elife.txt
@@ -13,29 +13,28 @@ ____
 
 In the practical chapters of this book, I stop pummeling you with new
 theory for a brief moment, and instead work through a program. Theory
-is indispensable, but reading and understanding programs is the way
-you actually learn to program.
+is indispensable, when learning to program, but it should be
+accompanied by reading and understanding non-trivial programs.
 
-The example project for this chapter is to build a virtual ecosystem,
-a little world with creatures moving around in it, in which the
-animals are autonomous programs struggling for survival.
+Our project in this chapter is to build a virtual ecosystem, a little
+world with creatures moving around in it, in which the animals are
+autonomous programs struggling for survival.
 
 == Definition ==
 
 In order to make this task manageable, we radically simplify the
-concept of a “world”. Namely, we understand it to mean a
+concept of a _world_. Namely, we understand it to mean a
 two-dimensional grid with each entity taking up a full square of the
-grid. Each “turn”, all the animals in the world get a chance to take
+grid. Each _turn_, all the animals in the world 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.
-This tends to make things easier to model. Of course, it has the
-drawback of being crude and inaccurate. But this simulation is
-intended to be amusing, not accurate, so we can freely cut such
-corners.
+into units with a fixed size—squares for space and turns for time. Of
+course, this has the drawback of being crude and inaccurate. But our
+simulation is intended to be amusing, not accurate, so we can freely
+cut such corners.
 
-A world can be defined with a “plan”, which is an array of strings
+A world can be defined with a _plan_, which is an array of strings
 that lay out the world's grid, using one character per square, and a
 legend, which is an object that tells us, for each character, what it
 means.
@@ -67,9 +66,9 @@ guessed, are empty space.
 object. Such an object keeps track of the shape and content of the
 world and lets the critters inside move. It has a method `toString`,
 which converts the world back to a string similar to the plan it was
-based on, so that you can see what is going on inside of it. And a
-method `turn`, which allows all the critters in it take one turn, and
-updates the world to reflect their actions.
+based on, so that you can see what is going on inside of it. And it
+has a method `turn`, which allows all the critters in it take one
+turn, and updates the world to reflect their actions.
 
 == Representing space ==
 
@@ -92,7 +91,7 @@ Point.prototype.plus = function(other) {
 };
 ----
 
-Next, we'll want an object type that models the grid itself. A grid is
+Next, we need an object type that models the grid itself. A grid is
 part of a world, but we make it a separate object (which will be
 _part_ of a world object) in order to help keep the world object
 simple. The world will concern itself with world-related things, the
@@ -110,7 +109,7 @@ console.log(grid[1][2]);
 // → 2,1
 ----
 
-Or, we can use a single array, with size width × height, and decide
+Or, we can use a single array, with size width×height, and decide
 that the element at (x,y) is found at position x + y × width in the
 array.
 
@@ -126,8 +125,8 @@ console.log(grid[2 + 1 * 3]);
 methods on the grid object type, it doesn't matter to outside code
 which approach we take. I chose the second representation, because it
 makes it much easier to create the array. When calling the `Array`
-constructor with a single number as argument, it creates a new array
-of the given length, filled with `undefined` values.
+constructor with a single number as argument, it creates a new empty
+array of the given length.
 
 This code defines the `Grid` object, with some basic methods:
 
@@ -166,20 +165,20 @@ console.log(grid.get(new Point(1, 1)));
 
 == A critter's programming interface ==
 
-(((interface)))Before we can start to write a `World` constructor, we
-will have to think a little more about these “critter objects” that
-will be living inside it. I mentioned that the world will ask the
-critters what action they want to take. This works as follows: Each
-critter object has an `act` method that, when called, returns an
-_action_. An action is an object with a `type` property, which names
-the type of action the critter wants to take, for example `"move"`.
-The action may also contain extra information, such as the direction
-the critter wants to move in.
+(((interface)))Before we can start on the `World` constructor, we must
+get more specific about the critter objects that will be living inside
+of it. I mentioned that the world will ask the critters what action
+they want to take. This works as follows: Each critter object has an
+`act` method that, when called, returns an _action_. An action is an
+object with a `type` property, which names the type of action the
+critter wants to take, for example `"move"`. The action may also
+contain extra information, such as the direction the critter wants to
+move in.
 
 Critters are terribly myopic, and thus they can only see the squares
 directly around them on the grid. Seeing nearby objects can be useful
 when deciding which action to take. When the `act` method is called,
-it is given a “view” object that allows the critter to inspect its
+it is given a _view_ object that allows the critter to inspect its
 surroundings. We name each of the eight nearby squares (cardinal plus
 diagonal) with its compass name: `"n"` for North, `"ne"` for
 North-East, and so on. We'll use this object to map from direction
@@ -242,8 +241,8 @@ around it (for example when crowded into a corner by other critters).
 
 The `randomElement` function simply picks a random element from an
 array, using `Math.random` plus some arithmetic to get a random index.
-We'll use that again later (randomness is useful for simulations). We
-saw `Object.keys` in the previous chapter. It returns an array
+We'll use that again later (randomness can be useful in simulations).
+We saw `Object.keys` in the previous chapter. It returns an array
 containing all the property names in the given object. In this case,
 all the direction names.
 
@@ -387,16 +386,14 @@ test.method([5]);
 // → 15
 ----
 
-The function passed to `forEach` there is the result of the `bind`
-call, and thus have its `this` bound to the first argument given to
-`bind`—the outer function's `this` value (which holds the `test`
-object).
+The function passed to `forEach` is the result of the `bind` call, and
+thus has its `this` bound to the first argument given to ++bind++—the
+outer function's `this` value (which holds the `test` object).
 
-Most of the standard array higher-order methods, such as `forEach` and
-`map`, take an optional second argument that can also be used for this
-purpose. The value you pass there will be used as the `this` of the
-calls to the iteration function, so you could also express the example
-above in a slightly simpler way:
+Most of the standard higher-order methods on arrays, such as `forEach`
+and `map`, take an optional second argument that can also be used to
+provide a `this` for the calls to the iteration function. So you could
+also express the example above in a slightly simpler way:
 
 [source,javascript]
 ----
@@ -415,7 +412,7 @@ test.method([5]);
 This only works for higher-order functions that support this feature,
 so you'll often need to fall back to one of the other approaches.
 
-In our own higher-order functions, we can support such a “context”
+In our own higher-order functions, we can support such a _context_
 parameter by using the `call` method to call our argument function.
 For example, this `forEach` method for our `Grid` type, which calls a
 given function for each element in the grid that isn't null or
@@ -438,12 +435,13 @@ Grid.prototype.forEach = function(f, context) {
 
 == Animating life ==
 
-(((simulation)))The next goal is to write a method `turn` for the
+(((simulation)))The next step is to write a method `turn` for the
 world object, that gives the critters inside of it a chance to act. It
-will go over the whole grid, square by square, looking for objects
-with an `act` method. When it finds one, it calls that method to get
-an action object, and carries out the resulting action if it makes
-sense. For now, only `"move"` actions are understood.
+will go over the grid using the `forEach` method we just defined,
+looking for objects with an `act` method. When it finds one, it calls
+that method to get an action object, and carries out the resulting
+action if it makes sense. For now, only `"move"` actions are
+understood.
 
 There is one potential problem with this approach. Can you spot it? If
 we let critters move as we come across them, they may move to a square
@@ -507,27 +505,27 @@ the square where the critter used to be to hold null, and store the
 critter in the destination square.
 
 (((interface)))(((private property)))These two methods are not part of
-the external interface of a `World` object. They are internal details.
-Some languages provide ways to explicitly declare certain methods and
-properties “private” and signal an error when you try to use them from
-outside the object. JavaScript does not, so you will have to rely on
-some other form of communication to describe what is part of an
-object's interface. Sometimes it can be useful to use a naming scheme
-to distinguish between external and internal properties, for example
-by prefixing all internal ones with an underscore (‘_’). This will
-make accidental uses of properties that are not part of an object's
-interface easier to spot.
+the external interface of a `World` object. They are an internal
+detail. Some languages provide ways to explicitly declare certain
+methods and properties _private_ and signal an error when you try to
+use them from outside the object. JavaScript does not, so you will
+have to rely on some other form of communication to describe what is
+part of an object's interface. Sometimes it can help to use a naming
+scheme to distinguish between external and internal properties, for
+example by prefixing all internal ones with an underscore character
+(“_”). This will make accidental uses of properties that are not part
+of an object's interface easier to spot.
 
 (((defensive programming)))Note that `letAct` takes care to ignore
 nonsense input—it doesn't assume that the action's `direction`
 property is valid, or that the `type` property makes sense. This kind
-of “defensive” programming makes sense in some situations. The main
+of _defensive_ programming makes sense in some situations. The main
 reason for doing it is to validate inputs coming from sources we do
 not control (such as user or file input), but it can also be useful to
-isolate subsystems from each other. In this case, the idea is that the
-critters themselves can be programmed sloppily—they don't have to
-verify if their intended actions make sense, they can just request an
-action and the world will figure out whether to allow it.
+isolate subsystems from each other. In this case, the intention is
+that the critters themselves can be programmed sloppily—they don't
+have to verify if their intended actions make sense, they can just
+request an action and the world will figure out whether to allow it.
 
 The one missing part, the `View` type, looks like this:
 
@@ -672,17 +670,17 @@ WallFollower.prototype.act = function(view) {
 First, we need to be able to “compute” with directions. Since they are
 modeled by a set of strings, we need to define our own operation
 (`dirPlus`) to calculate relative directions. So `dirPlus("n", 1)`
-means one 45-degree turn clockwise from North, so `"ne"`. Similarly,
+means one 45-degree turn clockwise from North, giving `"ne"`. Similarly,
 `dirPlus("s", -2)` means 90 degrees counterclockwise from South, which
 is East.
 
 The function first looks up the index of the given direction in the
 `directionNames` array, then offsets it, takes the remainder of the
 result and 8, and then fetches the corresponding name from the array
-again. The extra “+++ 8++” is there because the ‘%’ operator, when
+again. The extra “+++ 8++” is there because the “%” operator, when
 given a negative number on the left hand side, will return a negative
 result. So we add another eight to make sure the sum is positive,
-under the requirement that the `n` argument is never less than -8.
+assuming that the `n` argument is never less than -8.
 
 The `act` method, in the simple case, only has to do the following: It
 starts “scanning” the critter's surroundings starting from its
@@ -781,8 +779,8 @@ LifeLikeWorld.prototype.letAct = function(critter, point) {
 };
 ----
 
-The pattern of deriving a type from another type was explained in
-Chapter 6. This `letAct` method delegates the work of actually
+The principle of deriving a type from another type was explained in
+Chapter 6. This new `letAct` method delegates the work of actually
 performing an action to various functions stored in the `actionTypes`
 object, under property names corresponding to the action's name. We
 will define these functions in a moment. It first checks whether an
@@ -824,7 +822,8 @@ Moving is more involved:
 ----
 actionTypes.move = function(critter, point, action) {
   var dest = this.checkDestination(action, point);
-  if (dest == null || critter.energy <= 1 ||
+  if (dest == null ||
+      critter.energy <= 1 ||
       this.grid.get(dest) != null)
     return false;
   critter.energy -= 1;
@@ -836,11 +835,10 @@ actionTypes.move = function(critter, point, action) {
 
 This one first checks whether the action provides a valid destination
 (using the `direction` property from the action) through the
-`checkDestination` method defined earlier, whether the critter has
-the energy required—moving costs one unit of energy—and whether the
-destination square is actually empty. If any of those fail, it returns
-false to tell `letAct` that no action was taken. Otherwise, it moves
-the critter, and subtracts the energy cost.
+`checkDestination` method defined earlier. If not, or when the
+destination isn't empty or the critter does not have the required
+energy, it returns false to tell `letAct` that no action was taken.
+Otherwise, it moves the critter, and subtracts the energy cost.
 
 // include_code
 
@@ -871,7 +869,8 @@ actionTypes.reproduce = function(critter, point, action) {
   var baby = elementFromChar(this.legend,
                              critter.originChar);
   var dest = this.checkDestination(action, point);
-  if (dest == null || critter.energy <= 2 * baby.energy ||
+  if (dest == null ||
+      critter.energy <= 2 * baby.energy ||
       this.grid.get(dest) != null)
     return false;
   critter.energy -= 2 * baby.energy;
@@ -892,7 +891,7 @@ longer hypothetical) and the energy is spent.
 
 == Populating the new world ==
 
-We now have the “framework” needed to simulate these lifelike
+We now have the framework needed to simulate these 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 attribute. So let
 us make new ones. First we'll write a plant, which is a rather simple
@@ -942,14 +941,14 @@ PlantEater.prototype.act = function(context) {
 };
 ----
 
-We'll use the ‘*’ character for plants, so that is what this creature
+We'll use the “*” character for plants, so that is what this creature
 looks for when it searches for food.
 
 == Bringing it to life ==
 
-And that gives us enough elements to try our new world. Imagine a
-grassy valley with a herd of herbivores in it, some boulders, and lush
-plant life everywhere.
+And that gives us enough elements to try our new world. Imagine the
+map below as a grassy valley with a herd of herbivores in it, some
+boulders, and lush plant life everywhere.
 
 // include_code
 
@@ -1051,15 +1050,15 @@ Having the inhabitants of our world go extinct after a few minutes is
 kind of depressing. To deal with this, we could try to create a
 smarter plant eater.
 
-Observing our ecosystem, there are several problems that I notice.
-Firstly, the herbivores are terribly greedy, stuffing themselves with
-any plant they see, and thus wiping out plant life in any area where
-they are plentiful. Secondly, their randomized movement (the
-`view.find` method returns a random direction when multiple directions
-are possible) causes them to stumble around ineffectively, often
-causing them to starve when there happen to be no plans in their
-immediate vicinity. And finally, they breed very fast, which makes the
-cycling between abundance and famine especially intense.
+Observing our ecosystem, there are several obvious problems. Firstly,
+the herbivores are terribly greedy, stuffing themselves with any plant
+they see, and thus wiping out plant life in any area where they are
+plentiful. Secondly, their randomized movement (due to the `view.find`
+method returning a random direction when multiple directions match)
+causes them to stumble around ineffectively, often causing them to
+starve when there happen to be no plans in their immediate vicinity.
+And finally, they breed very fast, which makes the cycling between
+abundance and famine especially intense.
 
 Write a new critter type that tries to address one or more of these
 points, and substitute it for the old `PlantEater` type in the valley
@@ -1116,7 +1115,7 @@ minimum energy level at which they reproduce. Of course, making the
 ecosystem more stable also makes it more boring. A handful of fat,
 immobile critters forever munching on a sea of plants, never
 reproducing, makes for a very stable ecosystem. But no one wants to
-see that.
+watch that.
 
 !!solution!!
 
@@ -1170,7 +1169,7 @@ animateWorld(new LifeLikeWorld(
 
 Many of the same tricks that worked for in the previous exercise also
 apply here. Making the predators big (large energy), and having them
-reproduce slowly, is recommended. That'll make them less vulnerable to
+reproduce slowly is recommended. That'll make them less vulnerable to
 periods of starvation when the herbivores are scarce.
 
 Beyond staying alive, keeping its food stock alive is the critter's
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@ These are the sources used to build the second edition of Eloquent
 JavaScript.
 
 The rewrite is a work in progress. Feedback welcome, in the form of
-issues and pull requests. Chapter 0 to 6 are in a more or less stable
+issues and pull requests. Chapter 0 to 7 are in a more or less stable
 state. Don't waste too much time on detailed correction of anything
 beyond that yet.
 
