Move to logical-style quote/punctuation

marijnh · marijnh · commit 1bf803f99b0b · 2014-01-24T12:02:16.000+01:00
diff --git a/00_intro.txt b/00_intro.txt
@@ -244,7 +244,7 @@ program to jump back and forth any more. The `while` language
 construct takes care of that. It continues executing the block
 (wrapped in braces) below it as long as the condition it was given
 holds: `count <= 10`, which means “`count` is less than or equal to
-10.” We no longer have to create a temporary value and compare that
+10”. We no longer have to create a temporary value and compare that
 to zero. This was an uninteresting detail, and the power of
 programming languages is that they take care of uninteresting details
 for us.
diff --git a/01_values.txt b/01_values.txt
@@ -153,7 +153,7 @@ multiplication. Putting an operator between two values will
 new value.
 
 (((parentheses)))Does the example mean “add 4 and 100, and multiply
-the result by 11,” or is the multiplication done before the adding?
+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, this can be changed by wrapping the addition in
 parentheses:
diff --git a/02_program_structure.txt b/02_program_structure.txt
@@ -370,7 +370,7 @@ The `isNaN` function is a standard function that return `true` if the
 argument it is given is `NaN`. The `Number` function happens to return
 `NaN` when you give it a string that doesn't represent a valid number.
 Thus, the condition expresses “unless `theNumber` is not-a-number, do
-this.”
+this”.
 
 (((else keyword)))Often you have not only code that must be executed
 when a certain condition holds but also code that handles the other
diff --git a/03_functions.txt b/03_functions.txt
@@ -348,11 +348,11 @@ context from the stack, and uses it to continue execution.
 (((stack overflow)))(((recursion)))This stack requires space in the
 computer's memory to be stored. When the stack grows too big, the
 computer will give up with a message like “out of stack space” or “too
-much recursion.” The following code illustrates that—it asks the
+much recursion”. The following code illustrates that—it asks the
 computer a really hard question, which causes an infinite
 back-and-forth between two functions. Or rather, it would be infinite,
 if we had an infinite stack. As it is, it will run out of space, or
-“blow the stack.”
+“blow the stack”.
 
 // test: no
 
@@ -380,7 +380,7 @@ alert("Hello", "Good Evening", "How do you do?");
 
 (((alert function)))The function `alert` officially accepts only one
 argument. Yet when you call it like this, it does not complain. It
-simply ignores the other arguments and shows you “Hello.”
+simply ignores the other arguments and shows you “Hello”.
 
 (((undefined value)))JavaScript is extremely broad-minded about the
 amount of arguments you pass to a function. If you pass too many, the
@@ -568,7 +568,7 @@ marginally faster.
 Regardless, recursion is not always just a less-efficient alternative
 to looping. Some problems are much 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.
 
 Consider this puzzle: By starting from the number 1 and repeatedly
diff --git a/04_data.txt b/04_data.txt
@@ -178,7 +178,7 @@ is described in chapter 6.
 
 Properties that contain functions are generally called _methods_ of
 the value they belong to. As in “`toUpperCase` is a method of a
-string.”
+string”.
 
 This example demonstrates some methods that array objects have:
 
diff --git a/05_higher_order.txt b/05_higher_order.txt
@@ -615,7 +615,7 @@ horizon.
 == The cost ==
 
 In the happy land of elegant code and pretty rainbows, there lives a
-mean spoil-sport monster called “_inefficiency_.”
+mean spoil-sport monster called “_inefficiency_”.
 
 Reducing the processing of an array into a sequence of cleanly
 separated steps that each do something with the array and produce a
diff --git a/06_object.txt b/06_object.txt
@@ -26,7 +26,7 @@ a brief history of objects as a programming construct.
 programming stories, starts with the problem of complexity. One
 philosophy is that this complexity can be made manageable by
 separating it into small compartments that are isolated from each
-other. These compartments ended up with the name “objects.”
+other. These compartments ended up with the name “objects”.
 
 (((encapsulation)))(((method)))(((interface)))An object is a hard
 shell that encapsulates the gooey complexity inside of it, and instead
diff --git a/07_elife.txt b/07_elife.txt
@@ -36,7 +36,7 @@ drawback of being crude and inaccurate. But this 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.
diff --git a/08_error.txt b/08_error.txt
@@ -191,7 +191,7 @@ console.log(testPoint());
 (((test suite)))(((testing frameworks)))Various pieces of helper
 software exist that help you build and run collections of tests (“test
 suites”), making them easier to write, and producing more informative
-information when they fail. These are called “testing frameworks.”
+information when they fail. These are called _testing frameworks_.
 
 == Debugging ==
 
@@ -440,7 +440,7 @@ What if `body` raises an exception? In that case, the call to
 `try` statements have. They may be followed by a `finally` block
 (instead of, or in addition to the `catch` block). This 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
+the `try` block”. If a function has to clean something up, the cleanup
 code should usually be put into a `finally` block:
 
 // include_code
diff --git a/10_modules.txt b/10_modules.txt
@@ -606,7 +606,7 @@ that works well requires quite a bit of insight and foresight.
 The best way to learn the value of good interface design is to use
 lots of interfaces, some good, some horrible. Experience will teach
 you what works and what doesn't. Never assume that a painful interface
-is “just the way it is.” Fix it, or wrap it in a new interface that
+is “just the way it is”. Fix it, or wrap it in a new interface that
 works better for you.
 
 === Predictability ===
diff --git a/11_language.txt b/11_language.txt
@@ -609,7 +609,7 @@ behavior attack
     launch arm-rockets
 ----
 
-This is what is usually called a “domain-specific language,” a
+This is what is usually called a _domain-specific language_, a
 language tailored to express a narrow domain of knowledge, which can
 be more expressive than a general-purpose programming language because
 it is designed to express exactly the things that need expressing in
