Control Structures

Continuations are programming abstractions that allow for manipulating the "future" of a computation. Amongst their many applications, they enable implementing unstructured program flow through higher-order control operators such as callcc. In this paper we develop a Hoare-style logic for the verification of programs with higher-order control, in the presence of dynamic state. This is done by designing a dependent type theory with first class callcc and abort operators, where pre-and postconditions of programs are tracked through types. Our operators are algebraic in the sense of Plotkin and Power, and Jaskelioff, to reduce the annotation burden and enable verification by symbolic evaluation. We illustrate working with the logic by verifying a number of characteristic examples.

Aspect-oriented programming supports the separation of concerns into traditional core concerns and cross-cutting aspects. Aspects typically contain new code fragments that are introduced to the system (such as advice or introductions) and a means of quantification ...

RESUMEN: En este trabajo hemos modelado un sistema de reformado de etanol con vapor y purificación de monóxido de carbono (CO). Dicho sistema está destinado a alimentar una pila de combustible tipo PEM. A partir del modelo hemos realizado un estudio de sensibilidad y controlabilidad enfatizando la influencia de la temperatura en las variables de salida de interés. Los resultados del estudio de controlabilidad se utilizan para la selección de las estructuras de control más convenientes.

RESUMEN: En este trabajo hemos modelado un sistema de reformado de etanol con vapor y purificación de monóxido de carbono (CO). Dicho sistema está destinado a alimentar una pila de combustible tipo PEM. A partir del modelo hemos realizado un estudio de sensibilidad y controlabilidad enfatizando la influencia de la temperatura en las variables de salida de interés. Los resultados del estudio de controlabilidad se utilizan para la selección de las estructuras de control más convenientes.

In any learnability setting, hypotheses are conjectured from some hypothesis space. Studied herein are the in uence on learnability of the presence or absence of certain control structures in the hypothesis space. First presented are control structure characterizations of some rather speciÿc but illustrative learnability results. The presence of these control structures is thereby shown essential to maintain full learning power. Then presented are the main theorems. Each of these non-trivially characterizes the invariance of a learning class over hypothesis space V and the presence of a particular projection control structure, called proj, in V as: V has suitable instances of all denotational control structures. In a sense, then, proj epitomizes the control structures whose presence need not help and whose absence need not hinder learning power.

One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for systems with shared memory, is the monitor . Over the past twenty years many kinds of monitors have been proposed and implemented, and many modern programming languages provide some form of monitor for concurrency control. This paper presents a taxonomy of monitors that encompasses all the extant monitors and suggests others not found in the literature or in existing programming languages. It discusses the semantics and performance of the various kinds of monitors suggested by the taxonomy, and it discusses programming techniques suitable to each.

A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation relies heavily on mutation as is the case in Java, its meaning is less clear, and much of its intended simplicity lost. This paper explores the definition and implementation of safe futures for Java. One can think of safe futures as truly transparent annotations on method calls, which designate opportunities for concurrency. Serial programs can be made concurrent simply by replacing standard method calls with future invocations. Most significantly, even though some parts of the program are executed concurrently and may indeed operate on shared data, the semblance of serial execution is nonetheless preserved. Thus, program reasoning is simplified since data dependencies present in a sequential program are not violated in a version augmented with safe futures. Besides presenting a programming model and API for safe futures, we formalize the safety conditions that must be satisfied to ensure equivalence between a sequential Java program and its futureannotated counterpart. A detailed implementation study is also provided. Our implementation exploits techniques such as object versioning and task revocation to guarantee necessary safety conditions. We also present an extensive experimental evaluation of our implementation to quantify overheads and limitations. Our experiments indicate that for programs with modest mutation rates on shared data, applications can use futures to profitably exploit parallelism, without sacrificing safety.