Index: doc/theses/jiada_liang_MMath/conclusion.tex
===================================================================
--- doc/theses/jiada_liang_MMath/conclusion.tex	(revision acab1bd77b1e5193ebd46506b2b435a29f3f0124)
+++ doc/theses/jiada_liang_MMath/conclusion.tex	(revision 29c8675099308007aaa5be2a10db2bc13c6dbca7)
@@ -2,5 +2,5 @@
 \label{c:conclusion}
 
-The goal of this work is to extend the simple and unsafe enumeration type in the C programming language into a complex and safe enumeration type in the \CFA programming language while maintaining backward compatibility with C.
+This work aims to extend the simple and unsafe enumeration type in the C programming language into a complex and safe enumeration type in the \CFA programming language while maintaining backward compatibility with C.
 Within this goal, the new \CFA enumeration should align with the analogous enumeration features in other languages to match modern programming expectations.
 Hence, the \CFA enumeration features are borrowed from a number of programming languages, but engineered to work and play with \CFA's type system and feature set.
@@ -8,13 +8,13 @@
 Strong type-checking of enumeration initialization and assignment provides additional safety, ensuring an enumeration only contains its enumerators.
 Overloading and scoping of enumerators significantly reduces the naming problem, providing a better software-engineering environment, with fewer name clashes and the ability to disambiguate those that cannot be implicitly resolved.
-Typed enumerations solve the data-harmonization problem increasing safety through better software engineering.
+Typed enumerations solve the data-harmonization problem, increasing safety through better software engineering.
 Moreover, integrating enumerations with existing control structures provides a consistent upgrade for programmers and a succinct and secure mechanism to enumerate with the new loop-range feature.
 Generalization and reuse are supported by incorporating the new enumeration type using the \CFA trait system.
-Enumeration traits define the meaning of an enumeration, allowing functions to be written that work on any enumeration, such as the reading and printing an enumeration.
-Using advanced duck typing, existing C enumerations can be extended so they work with all of the enumeration features, providing for legacy C code to be moved forward into the modern \CFA programming domain.
-Finally, I expanded the \CFA project's test-suite with multiple enumeration features tests with respect to implicit conversions, control structures, inheritance, interaction with the polymorphic types, and the features built on top of enumeration traits.
+Enumeration traits define the meaning of an enumeration, allowing functions to be written that work on any enumeration, such as the reading and printing of an enumeration.
+With advanced structural typing, C enumerations can be extended so they work with all of the enumeration features, providing for legacy C code to be moved forward into the modern \CFA programming domain.
+Finally, the \CFA project's test suite has been expanded with multiple enumeration features tests with respect to implicit conversions, control structures, inheritance, interaction with the polymorphic types, and the features built on top of enumeration traits.
 These tests ensure future \CFA work does not accidentally break the new enumeration system.
 
-The conclusion is that the new \CFA enumeration mechanisms achieve the initial goals, providing C programmers with an intuitive enumeration mechanism for handling modern programming requirements.
+In summary, the new \CFA enumeration mechanisms achieve the initial goals, providing C programmers with an intuitive enumeration mechanism for handling modern programming requirements.
 
 
@@ -51,5 +51,5 @@
 \end{cfa}
 \item
-Currently enumeration scoping is all or nothing. In some cases, it might be useful to
+Currently, enumeration scoping is all or nothing. In some cases, it might be useful to
 increase the scoping granularity to individual enumerators.
 \begin{cfa}
@@ -68,3 +68,9 @@
 typedef RGB.Red OtherRed; // alias
 \end{cfa}
+\item
+Label arrays are auxiliary data structures that are always generated for \CFA enumeration, which is a considerable program overhead. 
+It is helpful to provide a new syntax or annotation for a \CFA enumeration definition that tells the compiler the labels will not be used 
+throughout the execution. Therefore, \CFA optimizes the label array away. The @value()@ function can still be used on an enumeration constant, 
+and the function called is reduced to a @char *@ constant expression that holds the name of the enumerator. But if @value()@ is called on 
+a variable with an enumerated type, it returns an empty string since the label information is lost for the runtime.
 \end{enumerate}
