Index: doc/papers/concurrency/Paper.tex
===================================================================
--- doc/papers/concurrency/Paper.tex	(revision eb28d7ea94b43621e0966e9820a806a677e2e038)
+++ doc/papers/concurrency/Paper.tex	(revision b038fe4cf798121015401b752dccc8a99838b68c)
@@ -245,11 +245,12 @@
 \abstract[Summary]{
 \CFA is a polymorphic, non-object-oriented, concurrent, backwards-compatible extension of the C programming language.
-This paper discusses the design philosophy and implementation of its advanced control-flow and concurrency/parallelism features, along with the supporting runtime.
-These features are created from scratch as ISO C has only low-level and/or unimplemented concurrency, so C programmers continue to rely on library features, like C pthreads.
+This paper discusses the design philosophy and implementation of its advanced control-flow and concurrent/parallel features, along with the supporting runtime.
+These features are created from scratch as ISO C has only low-level and/or unimplemented concurrency, so C programmers continue to rely on library features like C pthreads.
 \CFA introduces modern language-level control-flow mechanisms, like coroutines, user-level threading, and monitors for mutual exclusion and synchronization.
-The design contributions provide significant programmer simplification and safety by eliminating spurious wakeup and barging in monitors.
-As well, multiple monitors can be safely acquired \emph{simultaneously} (deadlock free), which is fully integrated with the monitor synchronization mechanisms.
-These features also integrate with the \CFA polymorphic type-system and exception handling, while respecting the expectations and style of C programmers.
-Experimental results show comparable performance of the new features with similar (weaker) mechanisms in other concurrent programming-languages.
+Library extension for executors, futures, and actors are built on these basic mechanisms.
+The runtime provides significant programmer simplification and safety by eliminating spurious wakeup and reducing monitor barging.
+The runtime also ensures multiple monitors can be safely acquired \emph{simultaneously} (deadlock free), and this feature is fully integrated with all monitor synchronization mechanisms.
+All language features integrate with the \CFA polymorphic type-system and exception handling, while respecting the expectations and style of C programmers.
+Experimental results show comparable performance of the new features with similar mechanisms in other concurrent programming-languages.
 }%
 
@@ -265,9 +266,9 @@
 \section{Introduction}
 
-This paper discusses the design philosophy and implementation of advanced language-level control-flow and concurrency/parallelism extensions in \CFA and its runtime.
+This paper discusses the design philosophy and implementation of advanced language-level control-flow and concurrent/parallel features in \CFA~\cite{Moss18} and its runtime.
 \CFA is a modern, polymorphic, non-object-oriented\footnote{
 \CFA has features often associated with object-oriented programming languages, such as constructors, destructors, virtuals and simple inheritance.
 However, functions \emph{cannot} be nested in structures, so there is no lexical binding between a structure and set of functions (member/method) implemented by an implicit \lstinline@this@ (receiver) parameter.},
-backwards-compatible extension of the C programming language~\cite{Moss18}.
+backwards-compatible extension of the C programming language.
 Within the \CFA framework, new control-flow features are created from scratch.
 ISO \Celeven defines only a subset of the \CFA extensions, where the overlapping features are concurrency~\cite[\S~7.26]{C11}.
@@ -337,4 +338,6 @@
 \item
 providing statically type-safe interfaces that integrate with the \CFA polymorphic type-system and other language features.
+\item
+library extensions for executors, futures, and actors built on the basic mechanisms.
 \item
 a runtime system with no spurious wakeup.