OK notes.

Geoffrey Challen
1 parent 66b866ac
Showing 4 changed files with 32 additions and 33 deletions
certainty.tex
introduction.tex
maybe.tex
notes/OK-12242014.pdf
@@ -84,13 +84,13 @@ service tracks when alternative decisions change, runs \texttt{evaluate}
 evaluation logic when appropriate, and returns testing results to the
 \texttt{maybe} server.
  
-Because unpredictable runtime variable changes could cause crashes or
-incorrect behavior, our prototype currently only changes variable values when
-they are set using a \texttt{maybe} statement. If the app wants to enable
-periodic readaptation of certain global variables, such as the interval
-controlling a timer, it can do so by periodically resetting the value using
-another \texttt{maybe} statement. This ensures that \texttt{maybe} variables
-only change when the developer expects them to.
+\sloppypar{Because unpredictable runtime variable changes could cause crashes
+or incorrect behavior, our prototype currently only changes variable values
+when they are set using a \texttt{maybe} statement. If the app wants to
+enable periodic readaptation of certain global variables, such as the
+interval controlling a timer, it can do so by periodically resetting the
+value using another \texttt{maybe} statement. This ensures that
+\texttt{maybe} variables only change when the developer expects them to.}
  
 \subsubsection{Simulation or emulation}
  
@@ -116,14 +116,14 @@ Eventually code containing a number of \texttt{maybe} statements will be
 deployed on thousands or millions of devices. At this point, large-scale
 split testing and learning can begin. If the user community is large enough,
 then it may be possible to collect statistically-significant results even for
-all possible permutations of \texttt{maybe} alternatives. For apps
-with a small number of users, or comparatively large number of \texttt{maybe}
-statements, we can collect data for variations of one \texttt{maybe} statement 
-at a time while holding the others constant. As an adaptation policy is
-designed and deployed for the statement being tested, we begin to vary and 
-measure the next \texttt{maybe} statement. We
-will provide a developer web interface allowing the developer to determine
-which \texttt{maybe} statements should be tested at any given time.
+all possible permutations of \texttt{maybe} alternatives. For apps with a
+small number of users, or comparatively large number of \texttt{maybe}
+statements, we can collect data for variations of one \texttt{maybe}
+statement while holding the others constant. As an adaptation policy is
+designed and deployed for the statement being tested, we begin to vary and
+measure the next \texttt{maybe} statement. We will provide a web interface
+allowing the developer to determine which \texttt{maybe} statements should be
+tested at any given time.
  
 Each time a \texttt{maybe} statement is reached or \texttt{maybe} variable is
 set, the \texttt{maybe} system records:
@@ -100,20 +100,19 @@ them at runtime.}
 In this paper, we present a novel a language construct for expressing
 structured uncertainty: the \texttt{maybe} statement. Unlike previous
 approaches to adaptation that relied on language support, \texttt{maybe} does
-not attempt to encourage the programmer to provide more information about
-their app to allow the compiler to improve performance or guarantee
-correctness. Rather, \texttt{maybe} allows the programmer to express and
-structure uncertainty by providing two or more different
-\textit{alternatives} implementing multiple approaches to runtime adaptation,
-possibly by making the same energy-performance or energy-accuracy tradeoffs
-described previously. Conceptually, \texttt{maybe} extends the process of
-compilation and optimization to include post-deployment testing while also
-enabling flexible adaptation that may produce per-user, per-device, or
-temporally-varying solutions.
+not encourage programmers to provide more information about their app to
+allow the compiler to improve performance or guarantee correctness. Rather,
+\texttt{maybe} allows the programmer to express and structure uncertainty by
+providing two or more different \textit{alternatives} implementing multiple
+approaches to runtime adaptation, possibly by making the same
+energy-performance or energy-accuracy tradeoffs described previously.
+Conceptually, \texttt{maybe} extends the process of compilation and
+optimization to include post-deployment testing while also enabling flexible
+adaptation that may produce per-user, per-device, or time-varying solutions.
  
 Figure~\ref{fig-example-maybe} shows how our earlier example can be easily
-rewritten to use a \texttt{maybe} statement. Unlike the previous example
-\texttt{maybe} does not rely on the developer to implement a decision process
+rewritten using a \texttt{maybe} statement. Unlike the previous example
+\texttt{maybe}, does not rely on the developer to implement a decision process
 or correctly anticipate the effects of each alternative. Instead, the
 \texttt{maybe} system makes runtime choices about which alternative to use by
 measuring the tradeoffs produced by each alternative and (in this case)
@@ -55,7 +55,7 @@ Code flow can also represent uncertainty. Examples include using multiple
 algorithms to compute the same result or multiple code paths representing
 different tradeoffs between performance, energy, and quality.
 Figure~\ref{fig-example-maybe} shows the \texttt{maybe} statement in its
-simplest form controlling execution of multiple code blocks. If multiple
+simplest form, controlling execution of multiple code blocks. If multiple
 alternatives are specified, the system chooses one to execute; if only one
 alternative is specified, the system chooses whether or not to execute it.
 Single-alternative \texttt{maybe} statements can encapsulate or reorganize
@@ -83,8 +83,8 @@ rewrite-based prototype, described next in Section~\ref{sec-certainty}, we
 will revisit the question of nesting in future compiler-driven \texttt{maybe}
 systems.
  
-As a final remark, note that structured uncertainty is not randomness.
-Randomness weights multiple options statically---there is no right or wrong
-choice. In contrast, the \texttt{maybe} statement indicates that during any
-given execution one alternative may be the right choice---even if the
-developer or system cannot yet identify it.
+\sloppypar{As a final remark, note that structured uncertainty is not
+randomness. Randomness weights multiple options statically---there is no
+right or wrong choice. In contrast, the \texttt{maybe} statement indicates
+that during any given execution one alternative may be the right
+choice---even if the developer or system cannot yet identify it.}