rebuild

Author: justinmeiners

01_data_structures.html

@@ -120,7 +120,7 @@ <h2>Hello, World</h2>
 a room of programmers know it&rsquo;s going to be an empty set.
 That doesn&rsquo;t mean that you as an individual person doesn&rsquo;t know things, but intersection is going to be relatively small.</p>
 
-<p>Unfortunatly we&rsquo;ve got to a point where nobody teaches programming.
+<p>Unfortunately we&rsquo;ve got to a point where nobody teaches programming.
 Because there&rsquo;s no professor of computer science who has any idea how to program<sup id="fnref:6"><a href="#fn:6" rel="footnote">6</a></sup>.
 Part of what I am trying to do here is to start discussing
 little things like, how do we name variables?
@@ -145,7 +145,7 @@ <h2>Hello, World</h2>
 through the last brace, zero is returned.
 Because the standard UNIX convention, which became Universal
 convention, that on success you return zero.
-The language actually allows you to do things things like that.</p>
+The language actually allows you to do things like that.</p>
 
 <p>One warning, <a href="https://en.cppreference.com/w/cpp/io/cout"><code>cout</code></a> stuff works pretty much like how you think it works.
 However a friend of mine wrote something like:</p>
@@ -171,7 +171,7 @@ <h2>Number of unique elements</h2>
 pertaining to incorrect use of STL<sup id="fnref:9"><a href="#fn:9" rel="footnote">9</a></sup>.
 It&rsquo;s usually a one liner and the most egregious.</p>
 
-<p>The most most amazing thing is the following one liner which I will start in the
+<p>The most amazing thing is the following one liner which I will start in the
 beginning of the course, because it was just so important.
 We could weave the whole fabric of the course around this one little example.
 There was a range of integers. For example:</p>
@@ -216,7 +216,7 @@ <h3>Equality vs ordering</h3>
 One of the amazing things which we will discover is that ordering is very important.
 Things which we could do with ordering cannot be effectively done just with equality<sup id="fnref:13"><a href="#fn:13" rel="footnote">13</a></sup>.</p>
 
-<p>If we are going by the book we we will say sorting is good as long it does approximately <code>O(n log(n))</code> operations.
+<p>If we are going by the book we will say sorting is good as long it does approximately <code>O(n log(n))</code> operations.
 This is good for the books.
 It&rsquo;s actually not good for our code, because Big O
 could have an arbitrary coefficient.
@@ -381,7 +381,7 @@ <h2>Two fundamental performance metrics</h2>
 This is very good, we have to have that.
 But then we also need to have times for specific commonly used types.
 So these are two things which we need to do.
-Our goal is to to be able to measure this problem with <code>set</code> and with sort.
+Our goal is to be able to measure this problem with <code>set</code> and with sort.
 But, first we need to learn more about C++.</p>
 
 <a name="Code"></a>

02_regular_types.html

@@ -49,7 +49,7 @@ <h2>We don&rsquo;t know how to program yet</h2>
 I did interview at Facebook and let me tell you what I saw of that place&hellip;
 That was five years ago.
 Maybe they improved but I don&rsquo;t think so.
-Places tend to to decline.</p>
+Places tend to decline.</p>
 
 <p>You might say: &ldquo;Who are you to tell us?&rdquo;
 I am as guilty as any of you.

03_singleton.html

@@ -258,7 +258,7 @@ <h3>Virtual functions, virtual destructors, and OOP</h3>
 He tells you always declare destructor as virtual<sup id="fnref:7"><a href="#fn:7" rel="footnote">7</a></sup>.
 OK, he&rsquo;s wrong. Simple as that.</p>
 
-<p>What we do we want to create? Take type <code>T</code>, put it in a struct. Will the size of the thing increase?
+<p>What do we want to create? Take type <code>T</code>, put it in a struct. Will the size of the thing increase?
 No. It has no overhead.
 Singleton is the same size as <code>T</code>.
 It&rsquo;s the wonderful thing about singleton, and lets you pack them in arrays.
@@ -349,7 +349,7 @@ <h3>Why can&rsquo;t the compiler generate == and !=?</h3>
 Then they fixed it.
 They said, &ldquo;we&rsquo;ll just copy the bits&rdquo; and things would work.</p>
 
-<p>Equality is defined for all built-in types; <code>int</code>, <code>double</code>, <code>short</code>, <code>char</code>, pointers, etc.
+<p>Equality is defined for all built-in types: <code>int</code>, <code>double</code>, <code>short</code>, <code>char</code>, pointers, etc.
 So, if you have a struct, why can&rsquo;t you generate an equality that uses those?
 Two things are equal if all their members are equal.
 It&rsquo;s a sensible rule a compiler could do.</p>

04_instrumented.html

@@ -593,7 +593,7 @@ <h2>Code</h2>
 and the cover of that edition is labeled as such.<a href="#fnref:1" rev="footnote">&#8617;</a></li>
 <li id="fn:2">
 <p>Goto used to be the primary way to do control flow in programs,
-because it closely resembles how how machines and their languages work.</p>
+because it closely resembles  how machines and their languages work.</p>
 
 <p>For example, to implement a <code>while</code> loop, you might write:</p>
 

05_swap.html

@@ -143,7 +143,7 @@ <h3>Three tests of a language&rsquo;s ability to write components</h3>
 <p>So you say, &ldquo;Alex, why don&rsquo;t we use a new language?&rdquo;
 Go try implementing these three program in your favorite language.
 Do them in a general way.
-If they&rsquo;re at least relatively efficient, that is, they are not slower than specific things  written in the language, then let us talk.
+If they&rsquo;re at least relatively efficient, that is, they are not slower than specific things written in the language, then let us talk.
 If you cannot do it, let us stick with C++.
 I&rsquo;m just explaining the reasoning behind my choice of C++.</p>
 
@@ -396,7 +396,7 @@ <h2>Code</h2>
 
 <ol>
 <li><code>G</code> contains an identity element <code>e</code> in <code>G</code> such that <code>e * x = x * e = x</code> for all <code>x</code> in <code>G</code>.</li>
-<li>The operation <code>*</code> is associative. So <code>((x * y) * z)  = (x * (y * z))</code> for all <code>x, y, z</code> in <code>G</code>.</li>
+<li>The operation <code>*</code> is associative. So <code>((x * y) * z) = (x * (y * z))</code> for all <code>x, y, z</code> in <code>G</code>.</li>
 <li>Every element <code>x</code> in <code>G</code> has an inverse element <code>y</code> such that x * y = y * x = e.</li>
 </ol>
 

06_min_max.html

@@ -121,7 +121,7 @@ <h2>Weak orderings</h2>
 
 <p>The <code>==</code> is equality, not another equivalence relation.
 We can&rsquo;t conclude that with a weak ordering.
-We must overloaded symbols for what they commonly mean.</p>
+We must overload symbols for what they commonly mean.</p>
 
 <a name="Min"></a>
 <h2>Min</h2>
@@ -355,7 +355,7 @@ <h3>Implementation</h3>
 committee he always says, &ldquo;Alex you are too theoretical&rdquo;.
 I guess I am because I pay attention to
 these little details.
-But I claim to be able to to show you that
+But I claim to be able to show you that
 things like that will matter.</p>
 
 <p>Later we will generalize it on a bunch of things.

07_min_range.html

@@ -159,7 +159,7 @@ <h3>Forward iterator</h3>
 <a name="Finding-min-and-max-together"></a>
 <h2>Finding min and max together</h2>
 
-<p>How many comparisons do we need to to find the min of five elements?
+<p>How many comparisons do we need to find the min of five elements?
 Four.
 In general why do we need <code>n - 1</code> comparisons.
 Why no more? We don&rsquo;t need to compare an element with itself.

10_binary_counter.html

@@ -228,7 +228,7 @@ <h2>Binary counting and reduction</h2>
 But, they want to publish papers themselves and not tell you the general mechanism.</p>
 
 <p>Let us assume we have elements of type <code>T</code> that need to be paired or combined in some way,
-whether with <code>min</code>, <code>+</code>, <code>merge</code>, or any other assocative operation on <code>T</code>.
+whether with <code>min</code>, <code>+</code>, <code>merge</code>, or any other associative operation on <code>T</code>.
 What we can do is create an array called a &ldquo;counter&rdquo;.</p>
 
 <pre><code>   index: 0  1  ...   31
@@ -275,12 +275,12 @@ <h2>Binary counting and reduction</h2>
 
 <p>What if the index <code>1</code> slot was non-zero, after comparing <code>x</code> and <code>y</code>?
 Then the guy there already won one game.
-So, we must <strong>carry propogate</strong><sup id="fnref:10"><a href="#fn:10" rel="footnote">10</a></sup>.
+So, we must <strong>carry propagate</strong><sup id="fnref:10"><a href="#fn:10" rel="footnote">10</a></sup>.
 Repeat the same process all the way up the counter, until we find a slot which is zero.
 What if the counter is full, and has no zero slots?
 That&rsquo;s called an <strong>overflow</strong>.</p>
 
-<p>We borrow terminology from binary integer arithemtic because
+<p>We borrow terminology from binary integer arithmetic because
 our counter works just like a binary integer counting up:</p>
 
 <pre><code>0 0 0
@@ -293,7 +293,7 @@ <h2>Binary counting and reduction</h2>
 1 1 1
 </code></pre>
 
-<p>But instead of 0 and 1 in each slot or &ldquo;bit&rdquo; we have arbitary elements that are combined with an associative operation.</p>
+<p>But instead of 0 and 1 in each slot or &ldquo;bit&rdquo; we have arbitrary elements that are combined with an associative operation.</p>
 
 <a name="Handling-overflow"></a>
 <h3>Handling overflow</h3>
@@ -469,8 +469,8 @@ <h3>Counter storage</h3>
 
 <p><strong>Exercise:</strong> Rewrite <code>min_element</code> using this code (just <code>min_element</code>, don&rsquo;t worry about second best).</p>
 
-<p><strong>Exercise:</strong>  If you want to implement <a href="https://en.wikipedia.org/wiki/Merge_sort">merge sort</a> you can use exactly the same device, since merge is associative. The idea with merge sort, is you only want to merge lists if they are roughly the same length and this helps you do it (see Chapter 12).
-    Write the associtative binary operation <code>merge</code> which can combine two sorted arrays into a sorted array.</p>
+<p><strong>Exercise:</strong> If you want to implement <a href="https://en.wikipedia.org/wiki/Merge_sort">merge sort</a> you can use exactly the same device, since merge is associative. The idea with merge sort, is you only want to merge lists if they are roughly the same length and this helps you do it (see Chapter 12).
+    Write the associative binary operation <code>merge</code> which can combine two sorted arrays into a sorted array.</p>
 
 <p><strong>Exercise:</strong> When we become grownups we learn about advanced data structures, such as <a href="https://en.wikipedia.org/wiki/Binomial_heap">binomial forest</a>. They use the same idea. Learn about this data structure and try to figure out where
     the counter could be used.</p>
@@ -535,7 +535,7 @@ <h2>Code</h2>
 See the definition of &ldquo;in-place memory usage&rdquo; at the end of the chapter.<a href="#fnref:6" rev="footnote">&#8617;</a></li>
 <li id="fn:7">
 <p>A binary function <code>f</code> is <a href="https://en.wikipedia.org/wiki/Associative_property">associative</a>
-if the the following holds for all <code>a, b, c</code> in its domain:</p>
+if the following holds for all <code>a, b, c</code> in its domain:</p>
 
 <pre><code>f(f(a, b), c)) = f(a, f(b, c))
 </code></pre>
@@ -576,7 +576,7 @@ <h2>Code</h2>
               * * *
 </code></pre>
 
-<p>Or as <a href="https://en.wikipedia.org/wiki/Peter_Gustav_Lejeune_Dirichlet)">Dirchlet</a> put it: &ldquo;Whether you arrange soldiers in rows or columns, you still have the same number of soldiers&rdquo;.</p>
+<p>Or as <a href="https://en.wikipedia.org/wiki/Peter_Gustav_Lejeune_Dirichlet)">Dirichlet</a> put it: &ldquo;Whether you arrange soldiers in rows or columns, you still have the same number of soldiers&rdquo;.</p>
 
 <p>An example of an operation which is not commutative is string concatenation.</p>
 
@@ -590,7 +590,7 @@ <h2>Code</h2>
 We distinguish between the left and right argument.<a href="#fnref:9" rev="footnote">&#8617;</a></li>
 <li id="fn:10">
 <p>The terms <strong>carry</strong> and <strong>overflow</strong>
-are closely associated the implementation of binary counting
+are closely associated with the implementation of binary counting
 or addition as an electrical circuit, called an <a href="https://en.wikipedia.org/wiki/Adder_(electronics)">adder</a>.</p>
 
 <p>A single bit adder has two inputs <code>a</code> and <code>b</code> for
@@ -611,7 +611,7 @@ <h2>Code</h2>
 </code></pre>
 
 <p>This adds a single digit, but we want to add entire numbers.
-To, do so we add an additional input <code>l</code> for carried digits
+To do so we add an additional input <code>l</code> for carried digits
 from lower place values.</p>
 
 <pre><code>a  b  l    c  s
@@ -640,7 +640,7 @@ <h2>Code</h2>
 <a href="https://signalvnoise.com/posts/2710-designed-by-apple-in-california">Designed in Cupertino</a>, assembled in China.
 So let&rsquo;s try to assemble our machine in Palo Alto.<a href="#fnref:11" rev="footnote">&#8617;</a></li>
 <li id="fn:12">
-<p>Floating point arithemetic can involve many tricky details,
+<p>Floating point arithmetic can involve many tricky details,
 but the basic issue Alex is referring to is straightforward.
 We often use scientific notation to write larger numbers as a decimal to a power,
 when they would otherwise be very long to write out.

11_min_1_2.html

@@ -55,20 +55,20 @@ <h2>Overview</h2>
 I pick this algorithm because it allows us to learn how to do decomposition
 and learn these components like <code>list_pool</code> and <code>binary_counter</code> along the way.</p>
 
-<p>Let me sketch the grand plan of the whole alogorithm.</p>
+<p>Let me sketch the grand plan of the whole algorithm.</p>
 
 <ol>
-<li><p>We already showed that we want to arrange our comparisons like a tennis tournmant,
+<li><p>We already showed that we want to arrange our comparisons like a tennis tournament,
 and <code>binary_counter</code> helps us do this.
 Instead of comparing by left reduction, we compare by balanced reduction.</p></li>
 <li><p>We also want to keep a history for each element of all
 the other elements which they have beat.
 This history will be used to determine the second-place guy.</p>
 
-<p> We will store this history in a list (using <code>list_pool</code>)
- along with each element in the binary counter.
- Note that the counter works on generic elements, so it doesn&rsquo;t
- need to be modified to know about this history tracking.</p></li>
+<p>We will store this history in a list (using <code>list_pool</code>)
+along with each element in the binary counter.
+Note that the counter works on generic elements, so it doesn&rsquo;t
+need to be modified to know about this history tracking.</p></li>
 </ol>
 
 
@@ -132,7 +132,7 @@ <h3>Inner loop</h3>
 <p>Notice that we use <code>std::min_element</code> on our list pool.
 Will that work?
 Yes, because we added iterators to our list pool.
-Define our <code>iterator</code> type;</p>
+Define our <code>iterator</code> type:</p>
 
 <pre><code>typedef typename list_pool&lt;I, std::size_t&gt;::iterator iterator;
 </code></pre>
@@ -230,7 +230,7 @@ <h3>Finishing the scaffolding</h3>
 
   typedef op_min1_2&lt;I, size_t, compare_type&gt; op_type;
   typedef binary_counter&lt;op_type&gt; counter_type;
-  typedef typename op_type::argument_type  result_type;
+  typedef typename op_type::argument_type result_type;
 
   // ...
 }
@@ -262,7 +262,7 @@ <h2>Why do we need the typename keyword?</h2>
 
 <p>Obviously what you are trying to do is extract <code>T</code>&rsquo;s <code>value_type</code>
 and use it here.
-Let us try to to follow the committees logic.
+Let us try to follow the committees logic.
 The logic says maybe <code>T::value_type</code> refers to a static variable
 in <code>T</code>, which it could be of course.
 But, don&rsquo;t you know from the context that it&rsquo;s supposed to be a type?