Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision 037c072036cf82b132f6eaef0ff2728fbf7169ea)
+++ doc/papers/general/Paper.tex	(revision 4271a1e4868d8409544f87191716cd0a937eafe1)
@@ -2654,9 +2654,5 @@
 \subsection{Polymorphism}
 
-\CC is the most similar language to \CFA;
-both are extensions to C with source and runtime backwards compatibility.
-The fundamental difference is the engineering approach to maintain C compatibility and programmer expectation.
-While \CC provides good compatibility with C, it has a steep learning curve for many of its extensions.
-For example, polymorphism is provided via three disjoint mechanisms: overloading, inheritance, and templates.
+\CC provides three disjoint polymorphic extensions to C: overloading, inheritance, and templates.
 The overloading is restricted because resolution does not use the return type, inheritance requires learning object-oriented programming and coping with a restricted nominal-inheritance hierarchy, templates cannot be separately compiled resulting in compilation/code bloat and poor error messages, and determining how these mechanisms interact and which to use is confusing.
 In contrast, \CFA has a single facility for polymorphic code supporting type-safe separate-compilation of polymorphic functions and generic (opaque) types, which uniformly leverage the C procedural paradigm.
@@ -2712,22 +2708,34 @@
 Tuples are a fundamental abstraction in most functional programming languages, such as Standard ML~\cite{sml} and~\cite{Scala}, which decompose tuples using pattern matching.
 
-
-\subsection{Control Structures / Declarations / Literals}
-
-Java has default fall through like C/\CC.
-Pascal/Ada/Go/Rust do not have default fall through.
-\Csharp does not have fall through but still requires a break.
-Python uses dictionary mapping. \\
-\CFA choose is like Rust match.
-
-Java has labelled break/continue. \\
-Languages with and without exception handling.
-
-Alternative C declarations. \\
-Different references \\
-Constructors/destructors
-
-0/1 Literals \\
-user defined: D, Objective-C
+\subsection{C Extensions}
+
+\CC is the best known C-based language, and similar to \CFA in that both are extensions to C with source and runtime backwards compatibility.
+\CC and \CFA have been extensively compared in this paper, but the key difference between their design philosophies is that \CFA aims to be easy for C programmers to understand, by maintaining a procedural paradigm and avoiding complex interactions between extension features.
+\CC, on the other hand, has multiple overlapping features (such as the three forms of polymorphism), many of which have complex interactions with its object-oriented design. 
+As such, though \CC provides good runtime performance and compatibility with C, it has a steep learning curve for even experienced C programmers.
+
+There are many other C extension languages with less usage and dramatic changes than \CC. 
+Objective-C and Cyclone are two other extensions to C with different design goals than \CFA, as discussed above. 
+Many other languages extend C with more focused single features. 
+CUDA\cite{CUDA}, ispc\cite{Pharr12}, and Sierra\cite{Leissa14} add data-parallel primitives to C or \CC; such features have not yet been added to \CFA, but are not precluded by the design.
+Other C extensions attempt to provide a more memory-safe C;\TODO{find some} type-checked polymorphism in \CFA covers many of C's memory-safety holes, but more aggressive approaches such as annotating all pointer types with their nullability are contradictory to \CFA's backwards compatibility goals.
+
+% \subsection{Control Structures / Declarations / Literals}
+
+% Java has default fall through like C/\CC.
+% Pascal/Ada/Go/Rust do not have default fall through.
+% \Csharp does not have fall through but still requires a break.
+% Python uses dictionary mapping. \\
+% \CFA choose is like Rust match.
+
+% Java has labelled break/continue. \\
+% Languages with and without exception handling.
+
+% Alternative C declarations. \\
+% Different references \\
+% Constructors/destructors
+
+% 0/1 Literals \\
+% user defined: D, Objective-C
 
 \section{Conclusion and Future Work}