Context Navigation

-                      rd8f8d08
+                      r7372065
 \label{c:future}
-The following discussion covers both missing language features that affected my
-work and research based improvements.
 \section{Language Improvements}
+\todo{Future/Language Improvements seems to have gotten mixed up. It is
+presented as ``waiting on language improvements" but really its more
+non-research based impovements.}
 \CFA is a developing programming language. As such, there are partially or
 unimplemented features (including several broken components)
 that I had to workaround while building an EHM largely in
+unimplemented features of the language (including several broken components)
+that I had to workaround while building an exception handling system largely in
 the \CFA language (some C components).  The following are a few of these
 issues, and once implemented/fixed, how they would affect the exception system.
 …
 \item
 The implementation of termination is not portable because it includes
+hand-crafted assembly statements for each architecture, where the
+ARM processor was just added.
+% The existing compilers cannot translate that for other platforms and those
+% sections must be ported by hand to
+Supporting more hardware architectures in a general way is important.
+hand-crafted assembly statements.
+The existing compilers cannot translate that for other platforms and those
+sections must be ported by hand to
+support more hardware architectures, such as the ARM processor.
 \item
 Due to a type-system problem, the catch clause cannot bind the exception to a
 …
 @return@, \etc. The reason is that current code generation hoists a handler
 into a nested function for convenience (versus assemble-code generation at the
+@try@ statement). Hence, when the handler runs, its can access local variable
+in the lexical scope of the @try@ statement, but the closure does not capture
+local control-flow points so it cannot perform non-local transfers in the
+hoisted function.
+@try@ statement). Hence, when the handler runs, its code is not in the lexical
+scope of the @try@ statement, where the local control-flow transfers are
+meaningful.
 \item
 There is no detection of colliding unwinds. It is possible for clean-up code
 run during an unwind to trigger another unwind that escapes the clean-up code
 itself; such as a termination exception caught further down the stack or a
 cancellation. There do exist ways to handle this case, but currently there is no
 detection and the first unwind is simply forgotten, often leaving
+cancellation. There do exist ways to handle this but currently they are not
+even detected and the first unwind will simply be forgotten, often leaving
 it in a bad state.
 \item
 Finally, the exception system has not have a lot programmer testing.
 More time with encouraged usage will reveal new
 quality of life upgrades that can be made.
+Also the exception system did not have a lot of time to be tried and tested.
+So just letting people use the exception system more will reveal new
+quality of life upgrades that can be made with time.
 \end{itemize}
 …
 project, but was thrust upon it to do exception inheritance; hence, only
 minimal work is done. A draft for a complete virtual system is available but
 not finalized.  A future \CFA project is to complete that work and then
+it is not finalized.  A future \CFA project is to complete that work and then
 update the exception system that uses the current version.
 …
 exception traits. The most important one is an assertion to check one virtual
 type is a child of another. This check precisely captures many of the
 current ad-hoc correctness requirements.
+correctness requirements.
 The full virtual system might also include other improvement like associated
 types to allow traits to refer to types not listed in their header. This
 feature allows exception traits to not refer to the virtual-table type
 explicitly. %, removing the need for the current interface macros.
+explicitly, removing the need for the current interface macros.
 \section{Additional Raises}
 …
 Checked exceptions make exceptions part of a function's type by adding an
 exception signature. An exception signature must declare all checked
 exceptions that could propagate from the function, either because they were
 raised inside the function or a call to a sub-function. This improves safety
+exceptions that could propagate from the function (either because they were
+raised inside the function or came from a sub-function). This improves safety
 by making sure every checked exception is either handled or consciously
 passed on.
 However checked exceptions were never seriously considered for this project
 because they have significant trade-offs in usability and code reuse in
+because they have significant trade-offs in usablity and code reuse in
 exchange for the increased safety.
 These trade-offs are most problematic when trying to pass exceptions through
 …
 not support a successful-exiting stack-search without doing an unwind.
 Workarounds are possible but awkward. Ideally an extension to libunwind could
 be made, but that would either require separate maintenance or gaining enough
 support to have it folded into the code base.
+be made, but that would either require separate maintenance or gain enough
+support to have it folded into the standard.
 Also new techniques to skip previously searched parts of the stack need to be
 …
 to leave the handler.
 Currently, mimicking this behaviour in \CFA is possible by throwing a
 termination exception inside a resumption handler.
+termination inside a resumption handler.
 % Maybe talk about the escape; and escape CONTROL_STMT; statements or how

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 7372065 for doc/theses/andrew_beach_MMath/future.tex

Legend:

doc/theses/andrew_beach_MMath/future.tex

Download in other formats: