Don't capitalize after colon

marijnh · marijnh · commit 4c8c85272be9 · 2014-05-10T12:30:19.000+02:00
diff --git a/01_values.txt b/01_values.txt
@@ -227,7 +227,7 @@ press `enter`) also can't be put between quotes. The string has to
 stay on a single line.
 
 (((backslash)))To be able to have such characters in a string, the
-following notation is used: Whenever a backslash (“\”) is found
+following notation is used: whenever a backslash (“\”) is found
 inside quoted text, it indicates that the character after it has a
 special meaning. 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
@@ -336,7 +336,7 @@ console.log("Aardvark" < "Zoroaster")
 // → true
 ----
 
-The way strings are ordered is more or less alphabetic: Uppercase
+The way strings are ordered is more or less alphabetic: uppercase
 letters are always “less” than lowercase ones, so `"Z" < "a"` is
 true, and nonalphabetic characters (“!”, “-”, and so on) are also
 included in the ordering. The actual comparison is
diff --git a/03_functions.txt b/03_functions.txt
@@ -317,7 +317,7 @@ greet("Harry");
 console.log("Bye");
 ----
 
-A run through this program goes roughly like this: The call to
+A run through this program goes roughly like this: the call to
 `greet` causes control to jump to the start of that function (line
 2). It calls `console.log` (a built-in browser function), which takes
 control, does its job, then returns control to line 2. Then it
@@ -532,7 +532,7 @@ looping variant does. The function calls itself multiple times with
 different arguments to achieve the repeated multiplication.
 
 (((stack overflow)))But this implementation has one important
-problem: In typical JavaScript implementations, it's about ten times
+problem: in typical JavaScript implementations, it's about ten times
 slower than the looping version. Running through a simple loop is a
 lot cheaper than calling a function multiple times. On top of that,
 using a sufficiently large exponent to this function might cause the
@@ -576,7 +576,7 @@ with loops. Most often these are problems that require exploring or
 processing several “branches”, each of which might branch out again
 into more branches.
 
-Consider this puzzle: By starting from the number 1 and repeatedly
+Consider this puzzle: by starting from the number 1 and repeatedly
 either adding 5 or multiplying by 3, an infinite amount of new
 numbers can be produced. How would you write a function that, given a
 number, tries to find a sequence of such additions and
@@ -795,7 +795,7 @@ it's definitely also possible to have both side effects and return a
 value.)
 
 The first helper function in the farm example,
-`printZeroPaddedWithLabel`, is called for its side effect: It prints
+`printZeroPaddedWithLabel`, is called for its side effect: it prints
 a line. The second version, `zeroPad`, is called for its return
 value. It is no coincidence that the second is useful in more
 situations than the first. Functions that create values are easier to
diff --git a/04_data.txt b/04_data.txt
@@ -207,7 +207,7 @@ console.log(mack);
 
 (((Array type)))(((array,methods)))(((push method)))(((pop
 method)))(((join method)))The `push` method can be used to add values
-to the end of an array. The `pop` method does the opposite: It removes
+to the end of an array. The `pop` method does the opposite: it removes
 the value at the end of the array and returns it. An array of strings
 can be flattened to a single string with the `join` method. The
 argument given to `join` determines the text that is glued between the
@@ -582,7 +582,7 @@ should we store these correlations once we compute them?
 One possible way is to
 store all the correlations in an array, using objects with `name` and
 `value` properties. But that makes looking up the correlation for a given
-event somewhat cumbersome: You'd have to loop over the whole array
+event somewhat cumbersome: you'd have to loop over the whole array
 to find the object with the right `name`. We could wrap this lookup process
 in a function, but we would still be writing more code, and the
 computer would be doing more work, than necessary.
@@ -1175,7 +1175,7 @@ this exercise, write two functions, `reverseArray` and
 `reverseArrayInPlace`. The first, `reverseArray`, takes an array as
 argument and produces a _new_ array that has the same elements in the
 inverse order. The second, `reverseArrayInPlace` does what the
-`reverse` method does: It modifies the array given as argument in order
+`reverse` method does: it modifies the array given as argument in order
 to reverse its elements.
 
 Thinking back to the notes about side effects and pure functions in
@@ -1335,7 +1335,7 @@ whose values are also equal when compared with a recursive call to
 To find out whether to compare two things by identity (use the “===”
 operator for that) or by looking at their properties, you can use the `typeof` operator.
 If it produces `"object"` for both values, you should do a deep comparison. But
-you have to take one silly exception into account: By a
+you have to take one silly exception into account: by a
 historical accident, `typeof null` also produces `"object"`.
 
 ifdef::html_target[]
diff --git a/05_higher_order.txt b/05_higher_order.txt
@@ -698,7 +698,7 @@ the data is that of a family tree, rather than a flat list.
 
 The way we want to reduce this shape is by computing a value for a
 given person by combining values from their ancestors. This can be
-done recursively: If we are interested in person _A_, we have to
+done recursively: if we are interested in person _A_, we have to
 compute the values for __A__’s parents, which in turn requires us to
 compute the value for __A__’s grandparents, and so on. In principle,
 that'd require us to look at an infinite number of people, but since
diff --git a/06_object.txt b/06_object.txt
@@ -496,7 +496,7 @@ different shapes, as long as they support the interface it expects.
 I am going to work through a slightly more involved example in an
 attempt to give you a better idea what polymorphism, as well as
 object-oriented programming in general, looks like. The project is
-this: We will write a program that, given an array of arrays of table
+this: we will write a program that, given an array of arrays of table
 cells, builds up a string that contains a nicely laid out
 table—meaning that the columns are straight and the rows are aligned.
 Something like this:
diff --git a/07_elife.txt b/07_elife.txt
@@ -168,7 +168,7 @@ console.log(grid.get(new Vector(1, 1)));
 (((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
+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
@@ -682,7 +682,7 @@ 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,
 assuming that the `n` argument is never less than -8.
 
-The `act` method, in the simple case, only has to do the following: It
+The `act` method, in the simple case, only has to do the following: it
 starts “scanning” the critter's surroundings starting from its
 left-hand side, and going clockwise (towards the right) until it finds
 an empty square. It then moves in the direction of that empty square.
diff --git a/08_error.txt b/08_error.txt
@@ -353,7 +353,7 @@ jump back to a place that knows how to handle the problem. That is
 what _exception handling_ does.
 
 (((control flow)))(((raise (exception))))(((throw keyword)))(((call
-stack)))Exceptions are a mechanism that works like this: It is
+stack)))Exceptions are a mechanism that works like this: it is
 possible for code to _raise_ (or _throw_) an exception, which is
 simply a value. Raising an exception somewhat resembles a
 super-charged return from a function—it does not just jump out of the
@@ -424,7 +424,7 @@ Well, almost...
 
 == Cleaning up after exceptions ==
 
-(((cleaning up)))Consider the following situation: A function
+(((cleaning up)))Consider the following situation: a function
 `withContext`, wants to make sure that, during its execution, the
 top-level variable `context` holds a specific context value. After it
 finishes, it restores this variable to its old value.
diff --git a/09_regexp.txt b/09_regexp.txt
@@ -484,7 +484,7 @@ So if we match `"the 3 pigs"` there is a match between positions 4
    through the last box and have successfully matched this string.
 
 Conceptually, a regular expression engine looks for a match in a
-string as follows: It starts at the start of the string and tries a
+string as follows: it starts at the start of the string and tries a
 match there. In this case, there _is_ a word boundary there, so it'd
 get past the first box, but there is no digit, so it'd fail at the
 second box. Then it moves on to the second character in the string,
diff --git a/10_modules.txt b/10_modules.txt
@@ -775,7 +775,7 @@ into modules of the code. To refresh your memory, these are the
 functions and types defined in that chapter, in order of appearance.
 
 ----
-Point
+Vector
 Grid
 directions
 randomElement
@@ -814,7 +814,7 @@ functions.
 
 ----
 Module "grid"
-  Point
+  Vector
   Grid
   directions
 
diff --git a/15_game.txt b/15_game.txt
@@ -61,7 +61,7 @@ by handling key events.
 
 The screen- and keyboard-related code is only a tiny portion of the
 work we need to do to implement this game. Since everything looks like
-single-color boxes, drawing is uncomplicated: We create DOM elements,
+single-color boxes, drawing is uncomplicated: we create DOM elements,
 and use styling to give them a background color, size, and position.
 
 We can represent the background, which is a static grid, as a table of
@@ -1205,7 +1205,7 @@ arguments to a function, calling that function provides an elegant way
 to transition to a new state.
 
 In any case, when a level is lost, there should now be two possible
-state transitions: If that was the last life, we go back to level zero
+state transitions: if that was the last life, we go back to level zero
 with the starting amount of lives. If not, we repeat the current level
 with one less life remaining.
 
diff --git a/16_canvas.txt b/16_canvas.txt
@@ -704,7 +704,7 @@ canvas’ transformations entirely. It is also possible to save the
 current transformation, do some drawing and transforming, and then
 restore the old transformation. This is usually the proper thing to do
 for a function that needs to temporarily transform the coordinate
-system: First save whatever the code that called the function was
+system: first save whatever the code that called the function was
 using, then do its thing (on top of the existing transformation), and
 then revert to what it started with.
 
diff --git a/17_http.txt b/17_http.txt
@@ -68,7 +68,7 @@ to `DELETE` its main page, it'll probably refuse.
 
 The part after the method name is the path of the resource the request
 applies to. In the simplest case, a resource is simply a file on the
-server. But the protocol doesn't require it to be: It may be anything
+server. But the protocol doesn't require it to be: it may be anything
 that can be transferred _as if_ it is a file. Many servers generate
 the responses they produce on the fly. For example, if you open
 _http://twitter.com/marijnjh_, the server looks in its database for a
