Changes in doc/user/user.tex [816d61c:46e4440e]

File:

• doc/user/user.tex (modified) (37 diffs)

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Fri Jun 16 12:00:01 2017
-%% Update Count     : 2433
+%% Last Modified On : Tue Jun 13 11:50:27 2017
+%% Update Count     : 2403
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -43 +43 @@
 \usepackage[pagewise]{lineno}
 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
-\input{common}                                          % common CFA document macros
+\input{common}                                          % bespoke macros used in the document
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
 \usepackage{breakurl}
@@ -110 +110 @@
 \renewcommand{\subsectionmark}[1]{\markboth{\thesubsection\quad #1}{\thesubsection\quad #1}}
 \pagenumbering{roman}
-%\linenumbers                                            % comment out to turn off line numbering
+\linenumbers                                            % comment out to turn off line numbering
 
 \maketitle
@@ -881 +881 @@
 
 
+\subsection{Address-of Semantics}
+
+In C, ©&E© is an rvalue for any expression ©E©.
+\CFA extends the ©&© (address-of) operator as follows:
+\begin{itemize}
+\item
+if ©R© is an \Index{rvalue} of type ©T &$_1$...&$_r$© where $r \ge 1$ references (©&© symbols) than ©&R© has type ©T ®*®&$_{\color{red}2}$...&$_{\color{red}r}$©, \ie ©T© pointer with $r-1$ references (©&© symbols).
+
+\item
+if ©L© is an \Index{lvalue} of type ©T &$_1$...&$_l$© where $l \ge 0$ references (©&© symbols) then ©&L© has type ©T ®*®&$_{\color{red}1}$...&$_{\color{red}l}$©, \ie ©T© pointer with $l$ references (©&© symbols).
+\end{itemize}
+The following example shows the first rule applied to different \Index{rvalue} contexts:
+\begin{cfa}
+int x, * px, ** ppx, *** pppx, **** ppppx;
+int & rx = x, && rrx = rx, &&& rrrx = rrx ;
+x = rrrx;               // rrrx is an lvalue with type int &&& (equivalent to x)
+px = &rrrx;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (&x)
+ppx = &&rrrx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (&rx)
+pppx = &&&rrrx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (&rrx)
+ppppx = &&&&rrrx; // starting from &&&rrrx, &&&&rrrx is an rvalue with type int **** (&rrrx)
+\end{cfa}
+The following example shows the second rule applied to different \Index{lvalue} contexts:
+\begin{cfa}
+int x, * px, ** ppx, *** pppx;
+int & rx = x, && rrx = rx, &&& rrrx = rrx ;
+rrrx = 2;               // rrrx is an lvalue with type int &&& (equivalent to x)
+&rrrx = px;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (rx)
+&&rrrx = ppx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (rrx)
+&&&rrrx = pppx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (rrrx)
+\end{cfa}
+
+
+\subsection{Conversions}
+
+C provides a basic implicit conversion to simplify variable usage:
+\begin{enumerate}
+\setcounter{enumi}{-1}
+\item
+lvalue to rvalue conversion: ©cv T© converts to ©T©, which allows implicit variable dereferencing.
+\begin{cfa}
+int x;
+x + 1;                  // lvalue variable (int) converts to rvalue for expression
+\end{cfa}
+An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped.
+\end{enumerate}
+\CFA provides three new implicit conversion for reference types to simplify reference usage.
+\begin{enumerate}
+\item
+reference to rvalue conversion: ©cv T &© converts to ©T©, which allows implicit reference dereferencing.
+\begin{cfa}
+int x, &r = x, f( int p );
+x = ®r® + f( ®r® );  // lvalue reference converts to rvalue
+\end{cfa}
+An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
+
+\item
+lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
+\begin{cfa}
+int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
+f( ®x® );               // lvalue variable (int) convert to reference (int &)
+\end{cfa}
+Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
+Conversion can expand a type, where ©cv1© $>$ ©cv2©, \eg passing a ©const volatile int© to an ©int &©, which has high cost (\Index{warning});
+furthermore, if ©cv1© has ©const© but not ©cv2©, a temporary variable is created to preserve the immutable lvalue.
+
+\item
+rvalue to reference conversion: ©T© converts to ©cv T &©, which allows binding references to temporaries.
+\begin{cfa}
+int x, & f( int & p );
+f( ®x + 3® );   // rvalue parameter (int) implicitly converts to lvalue temporary reference (int &)
+®&f®(...) = &x; // rvalue result (int &) implicitly converts to lvalue temporary reference (int &)
+\end{cfa}
+In both case, modifications to the temporary are inaccessible (\Index{warning}).
+Conversion expands the temporary-type with ©cv©, which is low cost since the temporary is inaccessible.
+\end{enumerate}
+
+
 \subsection{Initialization}
 
@@ -961 +1038 @@
 
 
-\subsection{Address-of Semantics}
-
-In C, ©&E© is an rvalue for any expression ©E©.
-\CFA extends the ©&© (address-of) operator as follows:
-\begin{itemize}
-\item
-if ©R© is an \Index{rvalue} of type ©T &$_1$...&$_r$© where $r \ge 1$ references (©&© symbols) than ©&R© has type ©T ®*®&$_{\color{red}2}$...&$_{\color{red}r}$©, \ie ©T© pointer with $r-1$ references (©&© symbols).
-
-\item
-if ©L© is an \Index{lvalue} of type ©T &$_1$...&$_l$© where $l \ge 0$ references (©&© symbols) then ©&L© has type ©T ®*®&$_{\color{red}1}$...&$_{\color{red}l}$©, \ie ©T© pointer with $l$ references (©&© symbols).
-\end{itemize}
-The following example shows the first rule applied to different \Index{rvalue} contexts:
-\begin{cfa}
-int x, * px, ** ppx, *** pppx, **** ppppx;
-int & rx = x, && rrx = rx, &&& rrrx = rrx ;
-x = rrrx;               // rrrx is an lvalue with type int &&& (equivalent to x)
-px = &rrrx;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (&x)
-ppx = &&rrrx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (&rx)
-pppx = &&&rrrx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (&rrx)
-ppppx = &&&&rrrx; // starting from &&&rrrx, &&&&rrrx is an rvalue with type int **** (&rrrx)
-\end{cfa}
-The following example shows the second rule applied to different \Index{lvalue} contexts:
-\begin{cfa}
-int x, * px, ** ppx, *** pppx;
-int & rx = x, && rrx = rx, &&& rrrx = rrx ;
-rrrx = 2;               // rrrx is an lvalue with type int &&& (equivalent to x)
-&rrrx = px;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (rx)
-&&rrrx = ppx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (rrx)
-&&&rrrx = pppx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (rrrx)
-\end{cfa}
-
-
-\subsection{Conversions}
-
-C provides a basic implicit conversion to simplify variable usage:
-\begin{enumerate}
-\setcounter{enumi}{-1}
-\item
-lvalue to rvalue conversion: ©cv T© converts to ©T©, which allows implicit variable dereferencing.
-\begin{cfa}
-int x;
-x + 1;                  // lvalue variable (int) converts to rvalue for expression
-\end{cfa}
-An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped.
-\end{enumerate}
-\CFA provides three new implicit conversion for reference types to simplify reference usage.
-\begin{enumerate}
-\item
-reference to rvalue conversion: ©cv T &© converts to ©T©, which allows implicit reference dereferencing.
-\begin{cfa}
-int x, &r = x, f( int p );
-x = ®r® + f( ®r® );  // lvalue reference converts to rvalue
-\end{cfa}
-An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
-
-\item
-lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
-\begin{cfa}
-int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
-f( ®x® );               // lvalue variable (int) convert to reference (int &)
-\end{cfa}
-Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
-Conversion can expand a type, where ©cv1© $>$ ©cv2©, \eg passing a ©const volatile int© to an ©int &©, which has high cost (\Index{warning});
-furthermore, if ©cv1© has ©const© but not ©cv2©, a temporary variable is created to preserve the immutable lvalue.
-
-\item
-rvalue to reference conversion: ©T© converts to ©cv T &©, which allows binding references to temporaries.
-\begin{cfa}
-int x, & f( int & p );
-f( ®x + 3® );   // rvalue parameter (int) implicitly converts to lvalue temporary reference (int &)
-®&f®(...) = &x; // rvalue result (int &) implicitly converts to lvalue temporary reference (int &)
-\end{cfa}
-In both case, modifications to the temporary are inaccessible (\Index{warning}).
-Conversion expands the temporary-type with ©cv©, which is low cost since the temporary is inaccessible.
-\end{enumerate}
-
 
 \begin{comment}
+\section{References}
+
+By introducing references in parameter types, users are given an easy way to pass a value by reference, without the need for NULL pointer checks.
+In structures, a reference can replace a pointer to an object that should always have a valid value.
+When a structure contains a reference, all of its constructors must initialize the reference and all instances of this structure must initialize it upon definition.
+
+The syntax for using references in \CFA is the same as \CC with the exception of reference initialization.
+Use ©&© to specify a reference, and access references just like regular objects, not like pointers (use dot notation to access fields).
+When initializing a reference, \CFA uses a different syntax which differentiates reference initialization from assignment to a reference.
+The ©&© is used on both sides of the expression to clarify that the address of the reference is being set to the address of the variable to which it refers.
+
+
 From: Richard Bilson <rcbilson@gmail.com>
 Date: Wed, 13 Jul 2016 01:58:58 +0000
@@ -1200 +1213 @@
 \section{Routine Definition}
 
-\CFA also supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
+\CFA also supports a new syntax for routine definition, as well as ISO C and K\&R routine syntax.
 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
 \begin{cfa}
@@ -1220 +1233 @@
 in both cases the type is assumed to be void as opposed to old style C defaults of int return type and unknown parameter types, respectively, as in:
 \begin{cfa}
-[§\,§] g();                                                     §\C{// no input or output parameters}§
-[ void ] g( void );                                     §\C{// no input or output parameters}§
+[§\,§] g();                                             §\C{// no input or output parameters}§
+[ void ] g( void );                             §\C{// no input or output parameters}§
 \end{cfa}
 
@@ -1239 +1252 @@
 \begin{cfa}
 typedef int foo;
-int f( int (* foo) );                           §\C{// foo is redefined as a parameter name}§
+int f( int (* foo) );                   §\C{// foo is redefined as a parameter name}§
 \end{cfa}
 The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo.
@@ -1247 +1260 @@
 C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
 \begin{cfa}
-[ int ] f( * int, int * );                      §\C{// returns an integer, accepts 2 pointers to integers}§
-[ * int, int * ] f( int );                      §\C{// returns 2 pointers to integers, accepts an integer}§
+[ int ] f( * int, int * );              §\C{// returns an integer, accepts 2 pointers to integers}§
+[ * int, int * ] f( int );              §\C{// returns 2 pointers to integers, accepts an integer}§
 \end{cfa}
 The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate C-style declaration-syntax, as in:
 \begin{cfa}
 #define ptoa( n, d ) int (*n)[ d ]
-int f( ptoa( p, 5 ) ) ...                       §\C{// expands to int f( int (*p)[ 5 ] )}§
-[ int ] f( ptoa( p, 5 ) ) ...           §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
+int f( ptoa( p, 5 ) ) ...               §\C{// expands to int f( int (*p)[ 5 ] )}§
+[ int ] f( ptoa( p, 5 ) ) ...   §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
 \end{cfa}
 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
@@ -1276 +1289 @@
         int z;
         ... x = 0; ... y = z; ...
-        ®return;®                                                       §\C{// implicitly return x, y}§
+        ®return;® §\C{// implicitly return x, y}§
 }
 \end{cfa}
@@ -1286 +1299 @@
 [ int x, int y ] f() {
         ...
-}                                                                               §\C{// implicitly return x, y}§
+} §\C{// implicitly return x, y}§
 \end{cfa}
 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered.
-
-Named return values may be used in conjunction with named parameter values;
-specifically, a return and parameter can have the same name.
-\begin{cfa}
-[ int x, int y ] f( int, x, int y ) {
-        ...
-}                                                                               §\C{// implicitly return x, y}§
-\end{cfa}
-This notation allows the compiler to eliminate temporary variables in nested routine calls.
-\begin{cfa}
-[ int x, int y ] f( int, x, int y );    §\C{// prototype declaration}§
-int a, b;
-[a, b] = f( f( f( a, b ) ) );
-\end{cfa}
-While the compiler normally ignores parameters names in prototype declarations, here they are used to eliminate temporary return-values by inferring that the results of each call are the inputs of the next call, and ultimately, the left-hand side of the assignment.
-Hence, even without the body of routine ©f© (separate compilation), it is possible to perform a global optimization across routine calls.
-The compiler warns about naming inconsistencies between routine prototype and definition in this case, and behaviour is \Index{undefined} if the programmer is inconsistent.
 
 
@@ -1313 +1309 @@
 as well, parameter names are optional, \eg:
 \begin{cfa}
-[ int x ] f ();                                                 §\C{// returning int with no parameters}§
-[ * int ] g (int y);                                    §\C{// returning pointer to int with int parameter}§
-[ ] h ( int, char );                                    §\C{// returning no result with int and char parameters}§
-[ * int, int ] j ( int );                               §\C{// returning pointer to int and int, with int parameter}§
+[ int x ] f ();                                 §\C{// returning int with no parameters}§
+[ * int ] g (int y);                    §\C{// returning pointer to int with int parameter}§
+[ ] h (int,char);                               §\C{// returning no result with int and char parameters}§
+[ * int,int ] j (int);                  §\C{// returning pointer to int and int, with int parameter}§
 \end{cfa}
 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
@@ -1324 +1320 @@
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
-[ int ] f( int ), g;
+[ int ] f(int), g;
 \end{cfa}
 &
 \begin{cfa}
-int f( int ), g( int );
+int f(int), g(int);
 \end{cfa}
 \end{tabular}
@@ -1334 +1330 @@
 Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} \eg:
 \begin{cfa}
-extern [ int ] f ( int );
-static [ int ] g ( int );
+extern [ int ] f (int);
+static [ int ] g (int);
 \end{cfa}
 
@@ -1343 +1339 @@
 The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
 \begin{cfa}
-* [ int x ] () fp;                                              §\C{// pointer to routine returning int with no parameters}§
-* [ * int ] (int y) gp;                                 §\C{// pointer to routine returning pointer to int with int parameter}§
-* [ ] (int,char) hp;                                    §\C{// pointer to routine returning no result with int and char parameters}§
-* [ * int,int ] ( int ) jp;                             §\C{// pointer to routine returning pointer to int and int, with int parameter}§
+* [ int x ] () fp;                      §\C{// pointer to routine returning int with no parameters}§
+* [ * int ] (int y) gp;         §\C{// pointer to routine returning pointer to int with int parameter}§
+* [ ] (int,char) hp;            §\C{// pointer to routine returning no result with int and char parameters}§
+* [ * int,int ] (int) jp;       §\C{// pointer to routine returning pointer to int and int, with int parameter}§
 \end{cfa}
 While parameter names are optional, \emph{a routine name cannot be specified};
 for example, the following is incorrect:
 \begin{cfa}
-* [ int x ] f () fp;                                    §\C{// routine name "f" is not allowed}§
+* [ int x ] f () fp;            §\C{// routine name "f" is not allowed}§
 \end{cfa}
 
@@ -1538 +1534 @@
         int ;                                   §\C{// disallowed, unnamed field}§
         int *;                                  §\C{// disallowed, unnamed field}§
-        int (*)( int );                 §\C{// disallowed, unnamed field}§
+        int (*)(int);                   §\C{// disallowed, unnamed field}§
 };
 \end{cfa}
@@ -1661 +1657 @@
 }
 int main() {
-        * [int]( int ) fp = foo();      §\C{// int (*fp)( int )}§
+        * [int](int) fp = foo();        §\C{// int (*fp)(int)}§
         sout | fp( 3 ) | endl;
 }
@@ -2782 +2778 @@
 
 
-\section{Constructors and Destructors}
+\subsection{Constructors and Destructors}
 
 \CFA supports C initialization of structures, but it also adds constructors for more advanced initialization.
@@ -3113 +3109 @@
 
 
-\begin{comment}
 \section{Generics}
 
@@ -3320 +3315 @@
         }
 \end{cfa}
-\end{comment}
 
 
@@ -3380 +3374 @@
         Complex *p3 = new(0.5, 1.0); // allocate + 2 param constructor
 }
+
 \end{cfa}
 
@@ -3391 +3386 @@
 
 
-\begin{comment}
 \subsection{Unsafe C Constructs}
 
@@ -3402 +3396 @@
 The exact set of unsafe C constructs that will be disallowed in \CFA has not yet been decided, but is sure to include pointer arithmetic, pointer casting, etc.
 Once the full set is decided, the rules will be listed here.
-\end{comment}
 
 
 \section{Concurrency}
+
+Today's processors for nearly all use cases, ranging from embedded systems to large cloud computing servers, are composed of multiple cores, often heterogeneous.
+As machines grow in complexity, it becomes more difficult for a program to make the most use of the hardware available.
+\CFA includes built-in concurrency features to enable high performance and improve programmer productivity on these multi-/many-core machines.
 
 Concurrency support in \CFA is implemented on top of a highly efficient runtime system of light-weight, M:N, user level threads.
@@ -3412 +3409 @@
 This enables a very familiar interface to all programmers, even those with no parallel programming experience.
 It also allows the compiler to do static type checking of all communication, a very important safety feature.
-This controlled communication with type safety has some similarities with channels in \Index*{Go}, and can actually implement channels exactly, as well as create additional communication patterns that channels cannot.
+This controlled communication with type safety has some similarities with channels in \Index*{Go}, and can actually implement
+channels exactly, as well as create additional communication patterns that channels cannot.
 Mutex objects, monitors, are used to contain mutual exclusion within an object and synchronization across concurrent threads.
 
-\begin{figure}
-\begin{cfa}
-#include <fstream>
-#include <coroutine>
-
-coroutine Fibonacci {
-        int fn;                                                         §\C{// used for communication}§
-};
-void ?{}( Fibonacci * this ) {
-        this->fn = 0;
-}
-void main( Fibonacci * this ) {
-        int fn1, fn2;                                           §\C{// retained between resumes}§
-        this->fn = 0;                                           §\C{// case 0}§
-        fn1 = this->fn;
-        suspend();                                                      §\C{// return to last resume}§
-
-        this->fn = 1;                                           §\C{// case 1}§
-        fn2 = fn1;
-        fn1 = this->fn;
-        suspend();                                                      §\C{// return to last resume}§
-
-        for ( ;; ) {                                            §\C{// general case}§
-                this->fn = fn1 + fn2;
-                fn2 = fn1;
-                fn1 = this->fn;
-                suspend();                                              §\C{// return to last resume}§
-        } // for
-}
-int next( Fibonacci * this ) {
-        resume( this );                                         §\C{// transfer to last suspend}§
-        return this->fn;
-}
-int main() {
-        Fibonacci f1, f2;
-        for ( int i = 1; i <= 10; i += 1 ) {
-                sout | next( &f1 ) | ' ' | next( &f2 ) | endl;
-        } // for
-}
-\end{cfa}
-\caption{Fibonacci Coroutine}
-\label{f:FibonacciCoroutine}
-\end{figure}
-
-
-\subsection{Coroutine}
-
-\Index{Coroutines} are the precursor to tasks.
-\VRef[Figure]{f:FibonacciCoroutine} shows a coroutine that computes the \Index*{Fibonacci} numbers.
+Three new keywords are added to support these features:
+
+monitor creates a structure with implicit locking when accessing fields
+
+mutex implies use of a monitor requiring the implicit locking
+
+task creates a type with implicit locking, separate stack, and a thread
 
 
@@ -3478 +3434 @@
 \end{cfa}
 
-\begin{figure}
-\begin{cfa}
-#include <fstream>
-#include <kernel>
-#include <monitor>
-#include <thread>
-
-monitor global_t {
-        int value;
-};
-
-void ?{}(global_t * this) {
-        this->value = 0;
-}
-
-static global_t global;
-
-void increment3( global_t * mutex this ) {
-        this->value += 1;
-}
-void increment2( global_t * mutex this ) {
-        increment3( this );
-}
-void increment( global_t * mutex this ) {
-        increment2( this );
-}
-
-thread MyThread {};
-
-void main( MyThread* this ) {
-        for(int i = 0; i < 1_000_000; i++) {
-                increment( &global );
-        }
-}
-int main(int argc, char* argv[]) {
-        processor p;
-        {
-                MyThread f[4];
-        }
-        sout | global.value | endl;
-}
-\end{cfa}
-\caption{Atomic-Counter Monitor}
-\caption{f:AtomicCounterMonitor}
-\end{figure}
-
-\begin{comment}
 Since a monitor structure includes an implicit locking mechanism, it does not make sense to copy a monitor;
 it is always passed by reference.
@@ -3571 +3480 @@
 }
 \end{cfa}
-\end{comment}
 
 
@@ -3579 +3487 @@
 A task provides mutual exclusion like a monitor, and also has its own execution state and a thread of control.
 Similar to a monitor, a task is defined like a structure:
-
-\begin{figure}
-\begin{cfa}
-#include <fstream>
-#include <kernel>
-#include <stdlib>
-#include <thread>
-
-thread First  { signal_once * lock; };
-thread Second { signal_once * lock; };
-
-void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
-void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
-
-void main( First * this ) {
-        for ( int i = 0; i < 10; i += 1 ) {
-                sout | "First : Suspend No." | i + 1 | endl;
-                yield();
-        }
-        signal( this->lock );
-}
-
-void main( Second * this ) {
-        wait( this->lock );
-        for ( int i = 0; i < 10; i += 1 ) {
-                sout | "Second : Suspend No." | i + 1 | endl;
-                yield();
-        }
-}
-
-int main( void ) {
-        signal_once lock;
-        sout | "User main begin" | endl;
-        {
-                processor p;
-                {
-                        First  f = { &lock };
-                        Second s = { &lock };
-                }
-        }
-        sout | "User main end" | endl;
-}
-\end{cfa}
-\caption{Simple Tasks}
-\label{f:SimpleTasks}
-\end{figure}
-
-
-\begin{comment}
 \begin{cfa}
 type Adder = task {
@@ -3681 +3540 @@
 \end{cfa}
 
+
 \subsection{Cooperative Scheduling}
 
@@ -3793 +3653 @@
 }
 \end{cfa}
-\end{comment}
-
+
+
+\section{Modules and Packages }
 
 \begin{comment}
-\section{Modules and Packages }
-
 High-level encapsulation is useful for organizing code into reusable units, and accelerating compilation speed.
 \CFA provides a convenient mechanism for creating, building and sharing groups of functionality that enhances productivity and improves compile time.
@@ -4462 +4321 @@
 
 
-\begin{comment}
 \subsection[Comparing Key Features of CFA]{Comparing Key Features of \CFA}
 
@@ -4840 +4698 @@
 
 
+\begin{comment}
 \subsubsection{Modules / Packages}
 
@@ -4919 +4778 @@
 }
 \end{cfa}
+\end{comment}
 
 
@@ -5079 +4939 @@
 
 \subsection{Summary of Language Comparison}
-\end{comment}
-
-
-\subsection[C++]{\CC}
+
+
+\subsubsection[C++]{\CC}
 
 \Index*[C++]{\CC{}} is a general-purpose programming language.
@@ -5103 +4962 @@
 
 
-\subsection{Go}
+\subsubsection{Go}
 
 \Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007 [.].
@@ -5119 +4978 @@
 
 
-\subsection{Rust}
+\subsubsection{Rust}
 
 \Index*{Rust} is a general-purpose, multi-paradigm, compiled programming language developed by Mozilla Research.
@@ -5133 +4992 @@
 
 
-\subsection{D}
+\subsubsection{D}
 
 The \Index*{D} programming language is an object-oriented, imperative, multi-paradigm system programming
@@ -5245 +5104 @@
 \item[Rationale:] keywords added to implement new semantics of \CFA.
 \item[Effect on original feature:] change to semantics of well-defined feature. \\
-Any \Celeven programs using these keywords as identifiers are invalid \CFA programs.
+Any ISO C programs using these keywords as identifiers are invalid \CFA programs.
 \item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism (see~\VRef{s:BackquoteIdentifiers}).
 \item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare.