Index: doc/theses/andrew_beach_MMath/existing.tex
===================================================================
--- doc/theses/andrew_beach_MMath/existing.tex	(revision b51e389c47d5e992da9c9fdfe10bf650fcd17966)
+++ doc/theses/andrew_beach_MMath/existing.tex	(revision 6071efc365ffe6b254040fac5d9263f8ea0a0cb8)
@@ -10,5 +10,5 @@
 
 Only those \CFA features pertaining to this thesis are discussed.
-Also, only new features of \CFA will be discussed, a basic familiarity with
+Also, only new features of \CFA will be discussed, a familiarity with
 C or C-like languages is assumed.
 
@@ -88,5 +88,5 @@
 Operator uses are translated into function calls using these names.
 These names are created by taking the operator symbols and joining them with
-@?@ where the arguments would go.
+@?@s to show where the arguments go.
 For example,
 infixed multiplication is @?*?@ while prefix dereference is @*?@.
@@ -95,5 +95,5 @@
 
 \begin{cfa}
-int ?+?(point a, point b) { return point{a.x + b.x, a.y + b.y}; }
+point ?+?(point a, point b) { return point{a.x + b.x, a.y + b.y}; }
 bool ?==?(point a, point b) { return a.x == b.x && a.y == b.y; }
 {
Index: doc/theses/andrew_beach_MMath/features.tex
===================================================================
--- doc/theses/andrew_beach_MMath/features.tex	(revision b51e389c47d5e992da9c9fdfe10bf650fcd17966)
+++ doc/theses/andrew_beach_MMath/features.tex	(revision 6071efc365ffe6b254040fac5d9263f8ea0a0cb8)
@@ -13,5 +13,5 @@
 \subsection{Raise / Handle}
 An exception operation has two main parts: raise and handle.
-These terms are sometimes also known as throw and catch but this work uses
+These terms are sometimes known as throw and catch but this work uses
 throw/catch as a particular kind of raise/handle.
 These are the two parts that the user writes and may
@@ -37,6 +37,6 @@
 Only raises inside the guarded region and raising exceptions that match the
 label can be handled by a given handler.
-Different EHMs use different rules to pick a handler,
-if multiple handlers could be used such as ``best match" or ``first found".
+If multiple handlers could can handle an exception,
+EHMs will define a rule to pick one, such as ``best match" or ``first found".
 
 The @try@ statements of \Cpp, Java and Python are common examples. All three
@@ -74,5 +74,5 @@
 case when stack unwinding is involved.
 
-If a matching handler is not guarantied to be found, the EHM needs a
+If a matching handler is not guaranteed to be found, the EHM needs a
 different course of action for the case where no handler matches.
 This situation only occurs with unchecked exceptions as checked exceptions
@@ -105,5 +105,5 @@
 
 \subsection{Completion}
-After the handler has finished the entire exception operation has to complete
+After the handler has finished, the entire exception operation has to complete
 and continue executing somewhere else. This step is usually simple,
 both logically and in its implementation, as the installation of the handler
@@ -126,5 +126,5 @@
 Virtual types and casts are not part of \CFA's EHM nor are they required for
 any EHM.
-However, it is one of the best ways to support an exception hierachy
+However, it is one of the best ways to support an exception hierarchy
 is via a virtual hierarchy and dispatch system.
 
@@ -441,5 +441,5 @@
 There is a global \defaultResumptionHandler{} is polymorphic over all
 resumption exceptions and preforms a termination throw on the exception.
-The \defaultTerminationHandler{} can be overriden by providing a new
+The \defaultTerminationHandler{} can be overridden by providing a new
 function that is a better match.
 
@@ -582,5 +582,5 @@
 Two things can expose differences between these cases.
 
-One is the existance of multiple handlers on a single try statement.
+One is the existence of multiple handlers on a single try statement.
 A reraise skips all later handlers on this try statement but a conditional
 catch does not.
@@ -588,8 +588,8 @@
 implicitly skipped, with a conditional catch they are not.
 Still, they are equivalently powerful,
-both can be used two mimick the behaviour of the other,
+both can be used two mimic the behaviour of the other,
 as reraise can pack arbitrary code in the handler and conditional catches
 can put arbitrary code in the predicate.
-% I was struggling with a long explination about some simple solutions,
+% I was struggling with a long explanation about some simple solutions,
 % like repeating a condition on later handlers, and the general solution of
 % merging everything together. I don't think it is useful though unless its
Index: doc/theses/andrew_beach_MMath/intro.tex
===================================================================
--- doc/theses/andrew_beach_MMath/intro.tex	(revision b51e389c47d5e992da9c9fdfe10bf650fcd17966)
+++ doc/theses/andrew_beach_MMath/intro.tex	(revision 6071efc365ffe6b254040fac5d9263f8ea0a0cb8)
@@ -4,5 +4,9 @@
 This thesis goes over the design and implementation of the exception handling
 mechanism (EHM) of
-\CFA (pernounced sea-for-all and may be written Cforall or CFA).
+\CFA (pronounced sea-for-all and may be written Cforall or CFA).
+\CFA is a new programming language that extends C, that maintains
+backwards-compatibility while introducing modern programming features.
+Adding exception handling to \CFA gives it new ways to handle errors and
+make other large control-flow jumps.
 
 % Now take a step back and explain what exceptions are generally.
@@ -27,6 +31,6 @@
 \end{center}
 
-Resumption exception handling calls a function, but asks the functions on the
-stack what function that is.
+Resumption exception handling seaches the stack for a handler and then calls
+it without adding or removing any other stack frames.
 \todo{Add a diagram showing control flow for resumption.}
 
@@ -77,5 +81,4 @@
 exceptions which unwind the stack as part of the
 Exceptions also can replace return codes and return unions.
-In functional languages will also sometimes fold exceptions into monads.
 
 The contributions of this work are: