Add crude pdf output via LaTeX

Author: marijnh

Diff for: .gitignore

@@ -21,6 +21,7 @@
 .tern-port
 /toc.txt
 /img/cover.xcf
+/img/generated/*
 /epub/[012]*.xhtml
 /epub/hints.xhtml
 /epub/img/*

Diff for: 02_program_structure.md

@@ -444,7 +444,7 @@ if (!isNaN(theNumber)) {
 {{index ["if keyword", chaining]}}
 
 If we have more than two paths to choose from, multiple `if`/`else`
-pairs can be “chained” together. Here's an example:
+pairs can be "chained" together. Here's an example:
 
 ```
 let num = Number(prompt("Pick a number"));
@@ -614,7 +614,7 @@ amount.
 {{index syntax, "while loop", "counter variable"}}
 
 Many loops follow the pattern seen in the `while` examples. First, a
-“counter” binding is created to track the progress of the loop. Then
+"counter" binding is created to track the progress of the loop. Then
 comes a `while` loop, whose test expression usually checks whether the
 counter has reached its end value. At the end of the loop body, the
 counter is updated to track progress.
@@ -639,7 +639,7 @@ for (let number = 0; number <= 12; number = number + 2) {
 This program is exactly equivalent to the
 [earlier](program_structure#loops) even-number-printing example. The
 only change is that all the ((statement))s that are related to the
-“state” of the loop are grouped together after `for`.
+"state" of the loop are grouped together after `for`.
 
 The ((parentheses)) after a `for` keyword must contain two
 ((semicolon))s. The part before the first semicolon _initializes_ the
@@ -720,7 +720,7 @@ iteration.
 
 {{index assignment, "+= operator", "-= operator", "/= operator", "*= operator", state, "side effect"}}
 
-Especially when looping, a program often needs to “update” a binding
+Especially when looping, a program often needs to "update" a binding
 to hold a value based on that binding's previous value.
 
 ```{test: no}
@@ -1010,7 +1010,7 @@ number, so you'll have to create an `if`/`else if`/`else` chain.
 {{index "|| operator", ["if keyword", chaining]}}
 
 The second version of the program has a straightforward solution and a
-clever one. The simple way is to add another conditional “branch” to
+clever one. The simple way is to add another conditional "branch" to
 precisely test the given condition. For the clever method, build up a
 string containing the word or words to output, and print either this
 word or the number if there is no word, potentially by making good use
@@ -1024,7 +1024,7 @@ hint}}
 
 Write a program that creates a string that represents an 8×8 grid,
 using newline characters to separate lines. At each position of the
-grid there is either a space or a “#” character. The characters should
+grid there is either a space or a "#" character. The characters should
 form a chess board.
 
 Passing this string to `console.log` should show something like this:

Diff for: 03_functions.md

@@ -393,18 +393,18 @@ function. In the other case, it jumps to the end of the program.
 
 The place where the computer stores this context is the _((call
 stack))_. Every time a function is called, the current context is
-stored on top of this “stack”. When the function returns, it removes
+stored on top of this "stack". When the function returns, it removes
 the top context from the stack and uses it to continue execution.
 
 {{index "infinite loop", "stack overflow", recursion}}
 
 Storing this stack requires space in the computer's memory. When the
-stack grows too big, the computer will fail with a message like “out
-of stack space” or “too much recursion”. The following code
+stack grows too big, the computer will fail with a message like "out
+of stack space" or "too much recursion". The following code
 illustrates this by asking the computer a really hard question, which
 causes an infinite back-and-forth between two functions. Rather, it
 _would_ be infinite, if the computer had an infinite stack. As it is,
-we will run out of space, or “blow the stack”.
+we will run out of space, or "blow the stack".
 
 ```{test: no}
 function chicken() {
@@ -507,7 +507,7 @@ console.log("C", "O", 2);
 {{index "call stack", "local binding", [function, "as value"], scope}}
 
 The ability to treat functions as values, combined with the fact that
-local bindings are “re-created” every time a function is called,
+local bindings are "re-created" every time a function is called,
 brings up an interesting question. What happens to local bindings when
 the function call that created them is no longer active?
 
@@ -536,7 +536,7 @@ can't trample on one another's local bindings.
 
 This feature—being able to reference a specific instance of local
 bindings in an enclosing function—is called _((closure))_. A function
-that “closes over” some local bindings is called _a_ closure. This
+that "closes over" some local bindings is called _a_ closure. This
 behavior not only frees you from having to worry about lifetimes of
 bindings but also allows for some creative use of function values.
 
@@ -645,7 +645,7 @@ if necessary.
 Recursion is not always just a inefficient alternative to looping.
 Some problems are really easier to solve with recursion than with
 loops. Most often these are problems that require exploring or
-processing several “branches”, each of which might branch out again
+processing several "branches", each of which might branch out again
 into more branches.
 
 {{id recursive_puzzle}}
@@ -883,7 +883,7 @@ and so on.
 
 A useful principle is not to add cleverness unless you are absolutely
 sure you're going to need it. It can be tempting to write general
-“((framework))s” for every bit of functionality you come across.
+"((framework))s" for every bit of functionality you come across.
 Resist that urge. You won't get any real work done, you'll just end up
 writing a lot of code that you'll never use.
 
@@ -1072,12 +1072,12 @@ In other words, a two-character string has length 2, and its
 characters have positions 0 and 1.
 
 Write a function `countBs` that takes a string as its only argument
-and returns a number that indicates how many uppercase “B” characters
+and returns a number that indicates how many uppercase "B" characters
 there are in the string.
 
 Next, write a function called `countChar` that behaves like `countBs`,
 except it takes a second argument that indicates the character that is
-to be counted (rather than counting only uppercase “B” characters).
+to be counted (rather than counting only uppercase "B" characters).
 Rewrite `countBs` to make use of this new function.
 
 {{if interactive

Diff for: 04_data.md

@@ -4,8 +4,8 @@
 
 {{quote {author: "Charles Babbage", title: "Passages from the Life of a Philosopher (1864)", chapter: true}
 
-On two occasions I have been asked, ‘Pray, Mr. Babbage, if you put
-into the machine wrong figures, will the right answers come out?’
+On two occasions I have been asked, 'Pray, Mr. Babbage, if you put
+into the machine wrong figures, will the right answers come out?'
 [...] I am not able rightly to apprehend the kind of confusion of
 ideas that could provoke such a question.
 
@@ -156,15 +156,15 @@ difference is in how `x` is interpreted. When using a dot, the word
 after the dot is the literal name of the property. When using square
 brackets, the expression between the brackets is _evaluated_ to get
 the property name. Whereas `value.x` fetches the property of `value`
-named “x”, `value[x]` tries to evaluate the expression `x` and uses
+named "x", `value[x]` tries to evaluate the expression `x` and uses
 the result as the property name.
 
 So if you know that the property you are interested in is called
-“length”, you say `value.length`. If you want to extract the property
+"length", you say `value.length`. If you want to extract the property
 named by the value held in the binding `i`, you say `value[i]`.
 Property names can be any string, and the dot notation only allows
 names that look like valid binding names, so if you want to access a
-property named “2” or “John Doe”, you must use square brackets:
+property named "2" or "John Doe", you must use square brackets:
 `value[2]` or `value["John Doe"]`.
 
 The elements in an ((array)) are stored as the array's properties, using
@@ -209,8 +209,8 @@ value whose property we called. How this works is described in
 [Chapter ?](object#obj_methods).
 
 Properties that contain functions are generally called _methods_ of
-the value they belong to. As in, “_toUpperCase_ is a method of a
-string”.
+the value they belong to. As in, "_toUpperCase_ is a method of a
+string".
 
 {{id array_methods}}
 
@@ -374,7 +374,7 @@ arms in a neat row, labeled with numbers.
 
 {{index journal, "weresquirrel example"}}
 
-So we can represent Jacques’ journal as an array of objects.
+So we can represent Jacques' journal as an array of objects.
 
 ```{test: wrap}
 let journal = [
@@ -448,7 +448,7 @@ contains the same properties as `object1` but lives a separate life.
 JavaScript's `==` operator, when comparing objects, will return `true`
 only if both objects are precisely the same value. Comparing different
 objects will return `false`, even if they have identical contents.
-There is no “deep” comparison operation built into JavaScript, which
+There is no "deep" comparison operation built into JavaScript, which
 looks at object's contents, but it is possible to write it yourself
 (which will be one of the [exercises](data#exercise_deep_compare) at
 the end of this chapter).
@@ -1220,7 +1220,7 @@ like a good approach.
 
 What we can do is _serialize_ the data. That means it is converted
 into a flat description. A popular format is called _((JSON))_
-(pronounced “Jason”), which stands for JavaScript Object Notation. It
+(pronounced "Jason"), which stands for JavaScript Object Notation. It
 is widely used as a data storage and communication format on the Web,
 even in languages other than JavaScript.
 
@@ -1305,7 +1305,7 @@ whether it does indeed return 55.
 {{index "optional argument"}}
 
 As a bonus assignment, modify your `range` function to take an
-optional third argument that indicates the “step” value used to build
+optional third argument that indicates the "step" value used to build
 up the array. If no step is given, the array elements go up by
 increments of one, corresponding to the old behavior. The function
 call `range(1, 10, 2)` should return `[1, 3, 5, 7, 9]`. Make sure it
@@ -1518,7 +1518,7 @@ list and the loop is finished.
 {{index recursion}}
 
 The recursive version of `nth` will, similarly, look at an ever
-smaller part of the “tail” of the list and at the same time count down
+smaller part of the "tail" of the list and at the same time count down
 the index until it reaches zero, at which point it can return the
 `value` property of the node it is looking at. To get the zeroeth
 element of a list, you simply take the `value` property of its head

Diff for: 05_higher_order.md

@@ -359,7 +359,7 @@ console.log(filter(SCRIPTS, script => script.living));
 {{index [function, "as value"], [function, application]}}
 
 This uses the argument named `test`, a function value, to fill in a
-“gap” in the computation. The `test` function is called for each
+"gap" in the computation. The `test` function is called for each
 element, and its return value determines whether an element is
 included in the returned array. 
 
@@ -394,7 +394,7 @@ which is easier to inspect.
 The `map` method transforms an array by applying a function to all of
 its elements and building a new array from the returned values. The
 new array will have the same length as the input array, but its
-content will have been “mapped” to a new form by the function.
+content will have been "mapped" to a new form by the function.
 
 ```
 function map(array, transform) {
@@ -739,7 +739,7 @@ function textScripts(text) {
   }).join(", ");
 }
 
-console.log(textScripts('英国的狗说“woof”, 俄罗斯的狗说“тяв”'));
+console.log(textScripts('英国的狗说"woof", 俄罗斯的狗说"тяв"'));
 // → 61% Han, 22% Latin, 17% Cyrillic
 ```
 
@@ -765,7 +765,7 @@ string it is given in between each of the elements of the array.
 
 Being able to pass function values to other functions is not just a
 gimmick—it's a deeply useful aspect of JavaScript. It allows us to
-write functions that model computations with “gaps” in them. The code
+write functions that model computations with "gaps" in them. The code
 that calls these functions can fill in the gaps by providing function
 values.
 
@@ -784,7 +784,7 @@ the position of the first element that matches a predicate.
 {{index "flattening (exercise)", "reduce method", "concat method", array}}
 
 Use the `reduce` method in combination with the `concat` method to
-“flatten” an array of arrays into a single array that has all the
+"flatten" an array of arrays into a single array that has all the
 elements of the input arrays.
 
 {{if interactive

Diff for: 06_object.md

@@ -246,7 +246,7 @@ A property like `speak(line)` in an object expression is a shorthand
 for defining methods. It creates a property called `speak` and gives
 it a function as its value.
 
-The “proto” rabbit acts as a container for the properties that are
+The "proto" rabbit acts as a container for the properties that are
 shared by all rabbits. An individual rabbit object, like the killer
 rabbit, contains properties that apply only to itself—in this case its
 type—and derives shared properties from its prototype.
@@ -268,6 +268,8 @@ of a class share the same value, such as ((method))s. Properties that
 differ per instance, such as our rabbits' `type` ((property)), need to
 be stored directly in the objects themselves.
 
+{{id constructors}}
+
 So in order to create an instance of a given class, you have to make
 an object that derives from the proper prototype, but you _also_ have
 to make sure it, itself, has the properties that instances of this
@@ -441,7 +443,7 @@ Calling `toString` on an array gives a result similar to calling
 `.join(",")` on it—it puts commas between the values in the array.
 Directly calling `Object.prototype.toString` with an array produces a
 different string. That function doesn't know about arrays, so it
-simply puts the word “object” and the name of the type between square
+simply puts the word "object" and the name of the type between square
 brackets.
 
 ```
@@ -1020,7 +1022,7 @@ to properties of the same name.
 
 Give the `Vec` prototype two methods, `plus` and `minus`, that 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
+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

Diff for: 07_robot.md

@@ -11,7 +11,7 @@ quote}}
 
 {{index "artificial intelligence", "Dijkstra, Edsger", "project chapter", "reading code", "writing code"}}
 
-In “project” chapters, I'll stop pummeling you with new theory for a
+In "project" chapters, I'll stop pummeling you with new theory for a
 brief moment and instead work through a program with you. Theory is
 indispensable when learning to program, but it is best accompanied by
 reading and understanding nontrivial programs.
@@ -120,7 +120,7 @@ programs are often hard to understand and thus easy to break.
 
 {{quote {author: "Joe Armstrong", title: "interviewed in Coders at Work"}
 
-The problem with object-oriented languages is they’ve got all this
+The problem with object-oriented languages is they've got all this
 implicit environment that they carry around with them. You wanted a
 banana but what you got was a gorilla holding the banana and the
 entire jungle.

Diff for: 08_error.md

@@ -331,7 +331,7 @@ Let's write out its value at the start of the loop.
 
 _Right_. Dividing 13 by 10 does not produce a whole number. Instead of
 `n /= base`, what we actually want is `n = Math.floor(n / base)` so
-that the number is properly “shifted” to the right.
+that the number is properly "shifted" to the right.
 
 {{index "JavaScript console", "debugger statement"}}
 
@@ -449,7 +449,7 @@ this stack, throwing away all the call contexts it encounters.
 If exceptions always zoomed right down to the bottom of the stack,
 they would not be of much use. They'd just provide a novel way to blow
 up your program. Their power lies in the fact that you can set
-“obstacles” along the stack to _catch_ the exception as it is zooming
+"obstacles" along the stack to _catch_ the exception as it is zooming
 down. Once you've caught an exception, you can do something with it to
 address the problem, and then continue to run the program.
 
@@ -575,8 +575,8 @@ there is no problem.
 But that isn't always practical. So there is another feature that
 `try` statements have. They may be followed by a `finally` block
 either instead of or in addition to a `catch` block. A `finally` block
-means “No matter _what_ happens, run this code after trying to run the
-code in the `try` block”. If a function has to clean something up, the
+means "No matter _what_ happens, run this code after trying to run the
+code in the `try` block". If a function has to clean something up, the
 cleanup code should usually be put into a `finally` block.
 
 ```{includeCode: true}