Index: doc/theses/mike_brooks_MMath/background.tex
===================================================================
--- doc/theses/mike_brooks_MMath/background.tex	(revision 0554c1ae242719e3bacbc48c46b1edaba83db864)
+++ doc/theses/mike_brooks_MMath/background.tex	(revision ab780e6afda20d69d650b2152ea5f5988f5f85e0)
@@ -236,5 +236,5 @@
 \lstinput{12-16}{bkgd-carray-decay.c}
 As the @sizeof(x)@ meaning changed, compared with when run on a similarly-spelled local variable declaration,
-GCC also gives this code the warning for the first assertion:
+@gcc@ also gives this code the warning for the first assertion:
 \begin{cfa}
 warning: 'sizeof' on array function parameter 'x' will return size of 'float *'
@@ -321,10 +321,11 @@
 This arrangement allocates @n@ elements on the @main@ stack frame for @ar@, called a \newterm{variable length array} (VLA), as well as 10 elements in the same stack frame for @b@.
 The variable-sized allocation of @ar@ is provided by the @alloca@ routine, which bumps the stack pointer.
-Note, the C standard supports VLAs, but the \CC standard does not;
+Note, the C standard supports VLAs~\cite[\S~6.7.6.2.4]{C11} as a conditional feature, but the \CC standard does not;
 both @gcc@ and @g++@ support VLAs.
 As well, there is misinformation about VLAs, \eg VLAs cause stack failures or are inefficient.
 VLAs exist as far back as Algol W~\cite[\S~5.2]{AlgolW} and are a sound and efficient data type.
 
-In situations where the stack size has a small bound (coroutines or user-level threads), unbounded VLAs can overflow the stack so a heap allocation is used.
+For high-performance applications, the stack size can be fixed and small (coroutines or user-level threads).
+Here, VLAs can overflow the stack, so a heap allocation is used.
 \begin{cfa}
 float * ax1 = malloc( sizeof( float[n] ) );
@@ -393,4 +394,33 @@
 \section{Linked List}
 
+Linked-lists are blocks of storage connected using one or more pointers.
+The storage block is logically divided into data and links (pointers), where the links are the only component used by the list structure.
+Since the data is opaque, list structures are often polymorphic over the data, which is normally homogeneous.
+
 
 \section{String}
+
+A string is a logical sequence of symbols, where the form of the symbols can vary significantly: 7/8-bit characters (ASCII/Latin-1), or 2/4/8-byte (UNICODE) characters/symbols or variable length (UTF-8/16/32) characters.
+A string can be read left-to-right, right-to-left, top-to-bottom, and have stacked elements (Arabic).
+
+An integer character constant is a sequence of one or more multibyte characters enclosed in single-quotes, as in @'x'@.
+A wide character constant is the same, except prefixed by the letter @L@, @u@, or @U@.
+With a few exceptions detailed later, the elements of the sequence are any members of the source character set;
+they are mapped in an implementation-defined manner to members of the execution character set.
+
+A C character-string literal is a sequence of zero or more multibyte characters enclosed in double-quotes, as in @"xyz"@.
+A UTF-8 string literal is the same, except prefixed by @u8@.
+A wide string literal is the same, except prefixed by the letter @L@, @u@, or @U@.
+
+For UTF-8 string literals, the array elements have type @char@, and are initialized with the characters of the multibyte character sequence, as encoded in UTF-8.
+For wide string literals prefixed by the letter @L@, the array elements have type @wchar_t@ and are initialized with the sequence of wide characters corresponding to the multibyte character sequence, as defined by the @mbstowcs@ function with an implementation-defined current locale.
+For wide string literals prefixed by the letter @u@ or @U@, the array elements have type @char16_t@ or @char32_t@, respectively, and are initialized with the sequence of wide characters corresponding to the multibyte character sequence, as defined by successive calls to the @mbrtoc16@, or @mbrtoc32@ function as appropriate for its type, with an implementation-defined current locale.
+The value of a string literal containing a multibyte character or escape sequence not represented in the executioncharacter set is implementation-defined.
+
+
+Another bad C design decision is to have null-terminated strings rather than maintaining a separate string length.
+\begin{quote}
+Technically, a string is an array whose elements are single characters.
+The compiler automatically places the null character @\0@ at the end of each such string, so programs can conveniently find the end.
+This representation means that there is no real limit to how long a string can be, but programs have to scan one completely to determine its length.
+\end{quote}