Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision 48b9b36d78295b9976f9e29cde21b9f3922eab9c)
+++ doc/papers/general/Paper.tex	(revision b9da958543715a012aa064957559bd6daf3afa63)
@@ -243,5 +243,5 @@
 Nevertheless, C, first standardized almost forty years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
 
-\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
+\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining source and runtime compatibility in the familiar C programming model.
 The four key design goals for \CFA~\cite{Bilson03} are:
 (1) The behaviour of standard C code must remain the same when translated by a \CFA compiler as when translated by a C compiler;
@@ -273,5 +273,5 @@
 Starting with a translator versus a compiler makes it easier and faster to generate and debug C object-code rather than intermediate, assembler or machine code.
 The translator design is based on the \emph{visitor pattern}, allowing multiple passes over the abstract code-tree, which works well for incrementally adding new feature through additional visitor passes.
-At the heart of the translator is the type resolver, which handles the polymorphic routine/type overload-resolution.
+At the heart of the translator is the type resolver, which handles the polymorphic function/type overload-resolution.
 % @plg2[8]% cd cfa-cc/src; cloc libcfa
 % -------------------------------------------------------------------------------
@@ -310,6 +310,6 @@
 
 Finally, it is impossible to describe a programming language without usages before definitions.
-Therefore, syntax and semantics appear before explanations;
-hence, patience is necessary until details are presented.
+Therefore, syntax and semantics appear before explanations, and related work (Section~\ref{s:RelatedWork}) is deferred until \CFA is presented;
+hence, patience is necessary until details are discussed.
 
 
@@ -329,5 +329,5 @@
 \end{quote}
 \vspace{-9pt}
-C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax. 
+C already has a limited form of ad-hoc polymorphism in its basic arithmetic operators, which apply to a variety of different types using identical syntax. 
 \CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable;
 Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C. 
@@ -1535,7 +1535,7 @@
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
-struct S { int `i`; int j; double m; } s, w;
+struct S { int `i`; int j; double m; } s, w;	$\C{// field i has same type in structure types S and T}$
 struct T { int `i`; int k; int m; } t, w;
-with ( s, t ) {
+with ( s, t ) {								$\C{// open structure variables s and t in parallel}$
 	j + k;									$\C{// unambiguous, s.j + t.k}$
 	m = 5.0;								$\C{// unambiguous, s.m = 5.0}$
@@ -2005,6 +2005,6 @@
 Destruction parameters are useful for specifying storage-management actions, such as de-initialize but not deallocate.}.
 \begin{cfa}
-struct VLA { int len, * data; };			$\C{// variable length array of integers}$
-void ?{}( VLA & vla ) with ( vla ) { len = 10;  data = alloc( len ); }  $\C{// default constructor}$
+struct VLA { int size, * data; };			$\C{// variable length array of integers}$
+void ?{}( VLA & vla ) with ( vla ) { size = 10;  data = alloc( size ); }  $\C{// default constructor}$
 void ^?{}( VLA & vla ) with ( vla ) { free( data ); } $\C{// destructor}$
 {
@@ -2019,9 +2019,9 @@
 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}:
 \begin{cfa}
-void ?{}( VLA & vla, int size, char fill ) with ( vla ) {  $\C{// initialization}$
-	len = size;  data = alloc( len, fill );
+void ?{}( VLA & vla, int size, char fill = '\0' ) {  $\C{// initialization}$
+	vla.[ size, data ] = [ size, alloc( size, fill ) ];
 }
 void ?{}( VLA & vla, VLA other ) {			$\C{// copy, shallow}$
-	vla.len = other.len;  vla.data = other.data;
+	vla = other;
 }
 \end{cfa}
@@ -2048,6 +2048,5 @@
 	y{ x };									$\C{// reallocate y, points to x}$
 	x{};									$\C{// reallocate x, not pointing to y}$
-	//  ^z{};  ^y{};  ^x{};
-}
+}	//  ^z{};  ^y{};  ^x{};
 \end{cfa}
 
@@ -2740,4 +2739,5 @@
 
 \section{Related Work}
+\label{s:RelatedWork}