Add 'what we don't cover'

content/blog/00_compiler_intro.md

@@ -66,6 +66,27 @@ and building up our project. We'll cover:
 
 We'll be creating a __lazily evaluated__, __functional__ language.
 
+#### What we won't cover
+Surely a guide written by one person can't be comprehensive. Not only
+do I have a finite amount of time to share this informatiom with you,
+but I also don't want to dilute the content of the posts in this series. Furthermore,
+many things that we'll be using for this tutorial are taught
+by numerous other sources, and those sources do a better job than I would.
+So, here are some things that you might want to know for this series,
+which won't be covered by the series itself:
+
+* [Theory of computation](https://en.wikipedia.org/wiki/Theory_of_computation),
+or, more specifically, [automata theory](https://en.wikipedia.org/wiki/Automata_theory).
+Deterministic and nondeterministic finite automata are briefly mentioned
+during tokenizing, and context free grammars are used in our parser. However,
+I don't provide a real explanation for either of those things.
+* [Functional programming](https://en.wikipedia.org/wiki/Functional_programming),
+with a touch of [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
+We jump straight into implementing the concepts from these.
+* C++. I do my best to use correct and modern C++, but I'm not an expert. I will
+not explain the syntax / semantics of C++ code included in these posts, but I will
+explain what my code does in the context of compilers.
+
 #### The syntax of our language
 Simon Peyton Jones, in his two works regarding compiling functional languages, remarks
 that most functional languages are very similar, and vary largely in syntax. That's