minor edits and proofreading

Author: petter-holmberg

00_foreword.md

@@ -50,7 +50,7 @@ code is reduced to its essential function,
 as opposed to traditional black-box layering
 which merely hides information.
 Programs written this way also tend to be fast,
-which contributes to its reusability.
+which contributes to their reusability.
 If a component doesn't perform, 
 there will always be some performance-sensitive application
 that can't use it.
@@ -145,7 +145,7 @@ this presentation will probably be difficult
 to follow.
 Try the first lesson.
 
-**How similar is Alex's vision to the  "modern C++" style?**
+**How similar is Alex's vision to the "modern C++" style?**
 
 The emphasis on value types and templates over dynamically allocated
 objects with virtual members is similar,

01_data_structures.md

@@ -4,7 +4,7 @@
 ## Reflections on Trusting Trust
 
 [Ken Thompson][ken] did many wonderful things. Probably more
-than any programmer, he influenced the programming style  which we have right
+than any programmer, he influenced the programming style which we have right
 now. While he did not invent C, that was done by his friend [Dennis Ritchie][dennis],
 he invented the programming style which underlies C.
 Dealing with pointers,
@@ -18,7 +18,7 @@ have to be abolished[^hoare-speech].
 The idea was that pointer is illegitimate thing. 
 Language designers were fully convinced that
 even if you provide pointers nobody should call them pointers.
-They  would call them something like [access types][access-types].
+They would call them something like [access types][access-types].
 They have to prohibit iterations, like you could never subtract pointers.
 [Niklaus Wirth][wirth], the designer of Pascal, was very certain that you should never allow
 subtraction between pointers.
@@ -40,7 +40,7 @@ So Ken made them practical[^minsky].
 
 Then he did UNIX, this totally brilliant operating system on which we all rely.
 All of our livelihoods come from Ken, in one shape or form.
-Do you remember the [fortune cookie program][fortune]?  
+Do you remember the [fortune cookie program][fortune]?
 One of the fortune cookies was: "it is all Ken's fault"[^fortune-quote].
 We have to remember that.
 
@@ -50,7 +50,7 @@ Mind it, at that point as far as I know he
 barely knew the moves.
 There was total dominance by Russian chess playing
 program [Kaissa][russia-chess] and two or three years he builds this specialized hardware,
-totally  revolutionizes the approach to just playing.
+totally revolutionizes the approach to just playing.
 Of course nobody remembers
 what Kaissa was.
 He is a guy who could enter in a
@@ -68,7 +68,7 @@ years of their collaboration not once they would attempt to do the same thing.
 They had this good sense to work on complementary things.
 Except once.
 Both of them needed to write an assembly program with about
-20 lines of code and continues Ken, "I checked it was character by character
+20 lines of code and continues Ken, "I checked, it was character by character
 identical".
 It sounds like mystical thing right, two people coming together,
 this is a Vulcan mind-meld (joke).
@@ -94,10 +94,10 @@ Imagine how wonderful it would be if you could understand what someone else wrot
 
 [^fortune-quote]: I have been unable to find any reference to this quote.
     Some older fortune files
-    such as [this file][plan-9-fortune]  from plan-9 contain similar quotes,
+    such as [this file][plan-9-fortune] from plan-9 contain similar quotes,
     such as "Maybe I should have screwed up"
 
-[^dennis]: Alex: In my opinion Dennis wasn' at genius like Ken,
+[^dennis]: Alex: In my opinion Dennis wasn't a genius like Ken,
      but obviously first class.
 
 [^teaching-programming]: Alex: At Stanford there's one guy who knows, but he's an emeritus (Donald Knuth).
@@ -141,7 +141,7 @@ Part of what I am trying to do here is to start discussing
 little things like, how do we name variables?
 Why is it important? We want to get to the point where
 everybody writes a consistent code, recognizable code.
-This is why I'm I want to go slow and develop so that we
+This is why I want to go slow and develop so that we
 all agree[^conventions].
 
 We have to start with a very very simple program. Most of you recognize it, right? [Hello World][hello-world].
@@ -268,18 +268,17 @@ That is a lot.
     One possible algorithm is using a lookup table.
     For example, one could allocate an array with `2^32` entries and count how many times integers are found only once.
 
-
-[^big-oh]: To say a function `f` is `O(g)` it's only required that `f` be bounded 
-     by a constant multiple for all inputs beyond some point.
+[^big-oh]: To say a function `f` is `O(g)` it's only required that `f` be bounded
+    by a constant multiple for all inputs beyond some point.
     Formally, if `f(x) <= Ag(x)` for all `x > M`, where `A` and `M` are constant real numbers
     (see "The Art of Computer Programming" 1.2.11).
 
     Alex will tend to say "order of" to distinguish `O(f)` from exactly `f`.
     In this section, Alex is observing that there is no requirement for `A` to be small.
 
 [^headers]: Alex: You didn't use to need `#include <set>` when I first did STL.
-    I had one gigantic a file called `stl.h`
-    At that time people said it's utterly unacceptable to twenty thousand lines of code.
+    I had one gigantic file called `stl.h`
+    At that time people said it's utterly unacceptable, you have twenty thousand lines of code.
     If you think about it nowadays it appears to be very funny. Twenty thousand is nothing.
     That's why `stl.h` was replaced with a gazillion little headers.
     Sometimes I have no idea what they are.
@@ -289,7 +288,7 @@ That is a lot.
     Some of you think it was a great language.
     They carefully designed a bunch of algorithms which work on arbitrary sequences
     and one of the algorithms was called [`remove-duplicates`][clhs-duplicates] and it relied on equality.
-    It actually would go through  `N` times rremoving things.
+    It actually would go through `N` times removing things.
     They did not sort. 
     They use equality.
     It did work and it worked exceptionally well for most of the applications.
@@ -365,15 +364,15 @@ Miracles are not possible.
 If you ask somebody to create a very
 complex data structure that's what you're going to get.
 You're going to get problems with node allocation.
-You are going to problems with rebalancing.
+You are going to get problems with rebalancing.
 You're going to get problem with whatever these advanced data
 structures do.
 These problems are going to get worse and worse.
 You're going to get a [cache miss][cache] on every step through the set.
 
-As our computers become faster, faster, and faster they're getting slower and
+As our computers become faster and faster and faster they're getting slower and
 slower and slower[^slower].
-Meaning that  going to the main memory is very slow.
+Meaning that going to the main memory is very slow.
 You want to have locality of reference. You want all your
 data that you are working on in the local cache. If you have a huge set or map it's not
 going to be like that. 
@@ -407,7 +406,7 @@ You need a `set` only if you need a thing which does not move things around.
 As long as something gets into a `set` and it is not erased the pointer, it is fixed.
 For example, him sitting in this chair is in the `set`.
 As long as he's in this set he will not move from his chair.
-You could find him constant time.
+You could find him in constant time.
 It's a very useful thing except most people do not use set for that.
 
 [^slower]: This performance description is based on several trends in computer architecture.

02_regular_types.md

@@ -79,7 +79,7 @@ You might think you can just put any type in a map,
 but actually there are requirements on the type,
 certain properties which are required for these containers to function.
 
-Let, us think about what my task was when I started working on the C++ STL.
+Let us think about what my task was when I started working on the C++ STL.
 It was to define standard data structures which will work for any reasonable subset of types.
 What is a reasonable subset of types?
 This is a little bit tricky but it's of paramount importance.
@@ -93,7 +93,7 @@ even more important than `int`.
 It has to work for pointer. 
 
 To understand all this, we're going to become a little bit theoretical.
-None of this stuff actually works  unless you understand at least a
+None of this stuff actually works unless you understand at least a
 little bit of theory.
 We will call such reasonable types `Regular`.
 What we will do is formally define a set of operators that all `Regular` types must have,
@@ -221,7 +221,7 @@ a copy, the original and the copy are equal.
 `!=` should always behave like: `!(a == b)`.
 My very strong point is that the semantics of
 inequality (`!=`) is absolutely and totally bound to the semantics of equality (`==`).
-You should not even be able to have a situation where they have different  semantics.
+You should not even be able to have a situation where they have different semantics.
 But, the standards committee disagrees with me on that.
 They say that you could have equality be equality and
 inequality be multiplication operator.
@@ -237,7 +237,7 @@ So even the paradigm of a member is the wrong paradigm.
 They are symmetric.
 
 [^smart-pointers]: This is likely a reference to how [`std::shared_ptr`][cpp-shared-ptr] behaves
-    which provides a form of automatic memory management.,
+    which provides a form of automatic memory management.
 
 ## Total orderings
 
@@ -255,7 +255,7 @@ to `TotallyOrdered`.
 
 `<` must obey the following [mathematical properties][total-order]:
 
-**Axiom 1:** Anti-reflexive: `!(a < a)`
+**Axiom 1:** Anti-reflexive: `!(a < a)`.
 
 **Axiom 2:** Transitive: If `a < b` and `b < c` then `a < c`.
 
@@ -265,15 +265,15 @@ to `TotallyOrdered`.
 
 In the same way that the semantics of `==` is related to `!=`,
 we can see the semantics of `<` must be totally bound to the semantics of equality.
-But furthermore,  `<` is related to four other operations which must also be defined:
+But furthermore, `<` is related to three other operations which must also be defined:
 
 1. `<` less than
 2. `>` greater than
 3. `<=` less than or equal to
 4. `>=` greater than or equal to
 
 If you provide them then they have to have natural meaning.
-For example, `!(a < b)`  should be `a >= b` otherwise the world
+For example, `!(a < b)` should be `a >= b` otherwise the world
 perishes.
 
 Later we will talk more about orderings, and define several different

03_singleton.md

@@ -4,7 +4,7 @@
 ## Learning C++ isn't as hard as it appears
 
 I talked to someone and he said "I have been programming in C++ for about eight years, but I never learned C++".
- That is a very common thing.
+That is a very common thing.
 He was just honestly admitting something which happens to be the case for most people.
 Most of us never learn programming languages.
 I never learned C++ I was just very
@@ -71,7 +71,7 @@ Why do I need template? Because we want to write something which takes one type
 another type.
 Let's forget C++ for a second.
 Mathematically speaking we want to write a type function: a thing which takes a type in
-and  generates new types.
+and generates new types.
 The `template` is the mechanism in C++ for doing just that.
 
 There are of course other type functions, even type functions in C. 
@@ -135,7 +135,7 @@ There is no reason to write to it before you first deallocate.
 Another way to think about it is to help preserve an invariant.
 There is some condition we need to assure that the values cannot change.
 
-For `singleton`, we pick struct because it's less typing.
+For `singleton`, we pick `struct` because it's less typing.
 *We should find the most minimal way of saying what we want to say*.
 
 [^communist]: Alex: Don't be so eager with making members of classes private.
@@ -280,10 +280,10 @@ I am showing you how you could program differently.
 If you program in an object-oriented way then many good things might happen.
 I don't know what they are but you are not going to be efficient.
 Bjarne used to joke that object
-oriented systems are those that slow graphics.
+oriented systems are those that have slow graphics.
 
 As time progresses, `++` is getting faster and faster and virtual function is getting slower and slower.
-Their spread is growing  and we're not going to address
+Their spread is growing and we're not going to address
 any parts of C++ in this course which slow the computations.
 
 If you want to learn about virtual I'm sure there are lots
@@ -395,7 +395,6 @@ They were not copyable and you couldn't pass them as arguments.
 Then they fixed it. 
 They said, "we'll just copy the bits" and things would work.
 
-
 Equality is defined for all built-in types; `int`, `double`, `short`, `char`, pointers, etc.
 So, if you have a struct, why can't you generate an equality that uses those?
 Two things are equal if all their members are equal.
@@ -404,7 +403,7 @@ It's a sensible rule a compiler could do.
 I never managed to ask Dennis Ritchie about it.
 But, I asked probably the second best person on the subject, [Steve Johnson][johnson], because
 he actually implemented all these assignments for structures and things like that.
-Steve told me,  "it was very hard because the bits in the padding might not be equal.
+Steve told me, "it was very hard because the bits in the padding might not be equal.
 If you compare bit by bit things which have equal members, but not equal bits in the padding, it will not work"[^padding].
 
 But, why should you compare bit by bit?
@@ -506,13 +505,12 @@ but expect nothing from them.
 Understand how all the other operators are defined in terms of `<`.
 Contemplate it.
 It's really important.
-It is mathematics, but that's mathematics every programmer should be able to do .
+It is mathematics, but that's mathematics every programmer should be able to do.
 
 [ip-quote]: https://en.wikipedia.org/wiki/Robustness_principle
 
 ### Specifying concepts
 
-
 Now let's talk about what kind of type `T` could be.
 Because we implemented all these operators, 
 `T` could be `SemiRegular`, `Regular`, or `TotallyOrdered`.
@@ -529,7 +527,6 @@ In `singleton` we add a comment to describe this:
 It's a good example of a **disjunctive concept**.
 `T` could be any of them.
 
-
 You might wonder how `==` will work, if you plug-in only a type `T`
 which is only `SemiRegular`.
 In C++, things don't have to be defined unless they are used.
@@ -569,8 +566,7 @@ Why did these Bell Labs guys introduce such a thing?
 Were they mad? 
 It was because they were lazy.
 They couldn't do it elegantly because they didn't
-have
-[function overloading][overloading].
+have [function overloading][overloading].
 
 In C++ we have `sqrt(int)`, `sqrt(double)`, etc
 You can pass `int`, or `double` and it does the right thing.
@@ -620,10 +616,10 @@ But, it did.
 
 `std::cin` is convertible to a pointer.
 If it fails, it returns `null` with type `void*`.
-Since  it is convertible to a pointer, you can apply one
+Since it is convertible to a pointer, you can apply one
 more conversion and convert this pointer to a Boolean.
 Then you could convert it to an integer.
-So `std::cin` becomes zero and you shifted by forty two positions.
+So `std::cin` becomes zero and you shifted by forty-two positions.
 Isn't that beautiful (joke)?
 
 The problem is they fixed this problem by
@@ -634,8 +630,9 @@ So they had to break the rule.
 Explicit conversions are not going to be called implicitly, unless
 they are in `while`, `if`, and other conditions which people used for input streams.
 So, the entire type system is screwed up (technical term), to work around some
+ancient design feature.
 The end of the story is avoid implicit conversions.
-Never rely on them it's impossible to avoid them.
+Never rely on them, it's impossible to avoid them.
 Even if you declare everything explicit there is still a
 context in C++ where implicit conversion will be done. 
 You should never rely on one type