Changeset 1f10959 for doc/theses/colby_parsons_MMAth/text/conclusion.tex

Timestamp:

Sep 6, 2023, 11:48:16 AM (9 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

92d8cda

Parents:

aae9c17

Message:

expanded upon intro and conclusion

File:

• doc/theses/colby_parsons_MMAth/text/conclusion.tex (modified) (2 diffs)

doc/theses/colby_parsons_MMAth/text/conclusion.tex

@@ -5 +5 @@
 % ======================================================================
 
-This thesis presented a suite of safe and efficient concurrency tools that provide users with the means to write scalable programs in \CFA through multiple avenues.
-If users prefer the message passing paradigm of concurrency, \CFA now provides message passing tools in the form of a performant actor system and channels.
+The goal of this thesis was to expand the concurrent support that \CFA offers to fill in gaps and support language users' ability to write safe and efficient concurrent programs.
+The presented features achieves this goal, and provides users with the means to write scalable programs in \CFA through multiple avenues.
+Additionally, the tools presented include safety and productivity features from deadlock detection, to detection of common programming errors, easy concurrent shutdown, and toggleable performance statistics.
+Programmers often have preferences between computing paradigms and concurrency is no exception.
+If users prefer the message passing paradigm of concurrency, \CFA now provides message passing utilities in the form of an actor system and channels.
 For shared memory concurrency, the mutex statement provides a safe and easy-to-use interface for mutual exclusion.
 The @waituntil@ statement aids in writing concurrent programs in both the message passing and shared memory paradigms of concurrency.
 Furthermore, no other language provides a synchronous multiplexing tool polymorphic over resources like \CFA's @waituntil@.
-
-These features are commonly used in conjunction to solve concurrent problems.
-The @waituntil@ statement, the @mutex@ statement, and channels will all likely see use in a program where a thread operates as an administrator or server which accepts and distributes work among channels based on some shared state.
-The @mutex@ statement sees use across almost all concurrent code in \CFA, since it is used with the stream operator @sout@ to provide thread-safe output.
-While not yet implemented, the polymorphic support of the @waituntil@ statement could see use in conjunction with the actor system to enable user threads outside the actor system to wait for work to be done, or for actors to finish.
-A user of \CFA does not have to solely subscribe to the message passing or shared memory concurrent paradigm.
-As such, channels in \CFA are often used to pass pointers to shared memory that may still need mutual exclusion, requiring the @mutex@ statement to also be used.
+This work successfully provides users with familiar concurrent language support, but with additional value added over similar utilities in other popular languages.
 
 On overview of the contributions in this thesis include the following:
@@ -25 +22 @@
 \item A @waituntil@ statement which tackles the hard problem of allowing a thread to safely synch\-ronously wait for some set of concurrent resources.
 \end{enumerate}
+
+The features presented are commonly used in conjunction to solve concurrent problems.
+The @waituntil@ statement, the @mutex@ statement, and channels will all likely see use in a program where a thread operates as an administrator or server which accepts and distributes work among channels based on some shared state.
+The @mutex@ statement sees use across almost all concurrent code in \CFA, since it is used with the stream operator @sout@ to provide thread-safe output.
+While not yet implemented, the polymorphic support of the @waituntil@ statement could see use in conjunction with the actor system to enable user threads outside the actor system to wait for work to be done, or for actors to finish.
+A user of \CFA does not have to solely subscribe to the message passing or shared memory concurrent paradigm.
+As such, channels in \CFA are often used to pass pointers to shared memory that may still need mutual exclusion, requiring the @mutex@ statement to also be used.
 
 From the novel copy-queue data structure in the actor system and the plethora of user-supporting safety features, all these utilities build upon existing concurrent tooling with value added.