doi:10.1016/j.tcs.2008.09.019 This is a PDF file of an unedited manuscript that has been accepted for publication. As a service to our customers we are providing this early version of the manuscript. The manuscript will undergo copyediting, typesetting, and review of the resulting proof before it is published in its final form. Please note that during the production process errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain. Manuscript

Asynchronous systems programs are usually written in an event-driven style which is tailored for performance rather than analyzability. Such programs have non-sequential control ow and make heavy use of heap data structures to store and retrieve state related to pending operations. As a result, existing tools that analyze sequential programs are ine ective in analyzing asynchronous systems components. We describe clarity, a programming language that enables analyzable design of asynchronous components. clarity has three novel features: (1) Nonblocking function calls that allow event-driven code to be written in a sequential style. If a blocking statement is encountered during the execution of such a call, the call returns and the remainder of the operation is automatically queued for later execution. (2) Coords, a set of high-level coordination primitives, encapsulate common interactions between asynchronous components and make high-level coordination protocols explicit. (3) Linearity annotations delegate coord protocol obligations to exactly one thread at each asynchronous function call, transforming a concurrent analysis problem into a sequential one. We demonstrate how these language features enable both a more intuitive expression of program logic and more e ective program analysis most checking is done using simple sequential analysis. We describe our experience in developing, testing, and analyzing a network device driver using clarity. 1.

Abstract. Event-driven programming is a widely accepted approach to building robust, scalable servers. However, it forces application programmers to manually maintain clientspecific state, leading to unsafe programs with obfuscated control flows. This paper introduces a Java language extension and its type system for structured event-driven programming, based on session types. Built on a simple extension of the standard session types, the proposed language enables safe, session type-directed event handling, supporting both traditional and novel event programming idioms. In addition to type soundness and communication safety, a theoretical framework of the language ensures event-handling safety and event progress, which have not been guaranteed by previous session type systems. We demonstrate applicability of the language through a conversion of existing event-based distributed applications. 1

We present a new programming model for deterministic parallel computation in a pure functional language. The model is monadic and has explicit granularity, but allows dynamic construction of dataflow networks that are scheduled at runtime, while remaining deterministic and pure. The implementation is based on monadic concurrency, which has until now only been used to simulate concurrency in functional languages, rather than to provide parallelism. We present the API with its semantics, and argue that parallel execution is deterministic. Furthermore, we present a complete workstealing scheduler implemented as a Haskell library, and we show that it performs at least as well as the existing parallel programming models in Haskell. 1.

First, I thank my dissertation advisor, Steve Zdancewic, who has always been supportive to me in the last five years. Steve taught me how to do research, co-authored many papers with me, gave me insightful feedbacks and practically line-by-line writing advices, encouraged me to look for research directions that I am most interested in and obtained funding for my dissertation research. As an advisor, he could not have been more helpful. My other mentors on programming languages research also deserve my thanks. Benjamin Pierce enlightened me on functional programming and the theory of programming languages; Stephanie Weirich impressed me on what type systems can do; Simon Peyton Jones educated me on the principles and philosophies of language design; Simon Marlow showed me how far one can go to make things run faster. In particular, I thank Benjamin Pierce and Stephanie Weirich for serving in my thesis committee. I thank all the PL Club members for sharing their knowledge in the weekly discussions. I particularly thank Geoffery Washburn for helping me out with the CIS-670 project and patiently explaining programming language concepts to me when I first started doing research in programming languages. I should also give special thanks to Stephen Tse who has been a great friend to talk about information-flow type systems and functional programming.

The development of a modern sensor network is very difficult because of the long-term unattended operating mode, diverse application requirements, and stringent resource constraints. To address these issues respectively, we present SenSpire OS, a predictable, flexible, and efficient operating system for wireless sensor networks (WSNs). We improve system predictability by two-phase interrupt servicing and application-aware interrupt scheduling; we achieve system flexibility by providing a hybrid model for both eventdriven programming and multithreaded programming; we retain system efficiency by employing the static approach and stack sharing technique. To be a practical sensornet OS that is easy-to-use and user-friendly, we design and implement a three-layer networking stack and an object-oriented programming language (CSpire) to enhance system usability and programming convenience. Having implemented SenSpire OS on the three most commonly deployed sensor node platforms—Mica2, MicaZ, TelosB, we evaluate its performance extensively. Results show that SenSpire OS ensures predictable temporal performances, provides a flexible hybrid model for programming, and is efficient in resource utilization. 1

Concurrency and distribution pose algorithmic and implementation challenges in developing reliable distributed systems, making the field an excellent testbed for evaluating programming language and verification paradigms. Several specialized domain-specific languages and extensions of memory-unsafe languages were proposed to aid distributed system development. We present an alternative to these approaches, showing that modern, higher-order, strongly typed, memory safe languages provide an excellent vehicle for developing and debugging distributed systems. We present Opis, a functional-reactive approach for developing distributed systems in Objective Caml. An Opis protocol description consists of a reactive function (called event function) describing the behavior of a distributed system node. The event functions in Opis are built from pure functions as building blocks, composed using the Arrow combinators. Such architecture aids reasoning about event functions both informally and using interactive theorem provers. For example, it facilitates simple termination arguments. Given a protocol description, a developer can use higherorder library functions of Opis to 1) deploy the distributed system, 2) run the distributed system in a network simulator with full-replay capabilities, 3) apply explicit-state model checking to the distributed system, detecting undesirable behaviors, and 4) do performance analysis on the system. We describe the design and implementation of Opis, and present our experience in using Opis to develop peer-to-peer overlay protocols, including the Chord distributed hash table and the Cyclon random gossip protocol. We found that using Opis results in high programmer productivity and leads to easily composable protocol descriptions. Opis tools were effective in helping identify and eliminate correctness and performance problems during distributed system development. Categories and Subject Descriptors D.3.2 [Programming

Asynchronous communication is an important feature of many concurrent systems. Central to any asynchronous protocol is the ability to split the creation of a communication action from its consumption. An important challenge to building expressive asynchronous communication abstractions is defining mechanisms that allow programmers to express composable post-creation and postconsumption behavior. Abstractions like CML’s synchronous events enable composable construction of synchronous communication protocols. Supporting similar functionality in an asynchronous setting leads to additional challenges because different threads of control are responsible for handling the action’s creation and consumption. In this paper, we present the design and rationale for asynchronous events, an abstraction that adapts CML’s synchronous events to support composable asynchronous protocols. Asynchronous events enable seamless composition of asynchronous protocols and interoperate cleanly with existing CML primitives. We discuss the definition of a number of useful asynchronous abstractions that can be built on top of asynchronous events (e.g., composable callbacks) and provide a detailed case study of how asynchronous events can be used to substantially improve the definition and performance of I/O intensive server applications. 1.

I would like to acknowledge the contribution of my supervisor Dr Nobuko Yoshida for her quidance and the time she devoted for this work. I would also like to acknowledge Raymont Hu for our cooperation in the development of the algebra. Last Dimitris Mostrous helped me to better understand background notions around the subject. This work develops a session type discipline for event driven programming models. Event models are used to describe asynchrony in concurrent systems. Session types is a typing system for π calculus developed for sound and safe process interaction. The studying of events through a session type definition presents great interest for concurrent systems. For the purpose of this thesis event driven models are studied in order to find their key properties that can be used for a theoretical definition of an event driven model. A process algebra based on π calculus is then developed to describe event driven programming. This algebra is based on asynchronous communication and it is extended with constructs that handle events. Some novelties are also present such as the asynchronous session creation. A proper session typing system, able to describe the nature of events, is defined along this process algebra. Through examples the algebra and the typing system are practically

Abstract. Recent research has shown how the formal modeling of concurrent systems can benefit from monadic structuring. With this approach, a formal system model is really a program in a domain specific language defined by a monad for shared-state concurrency. Can these models be compiled into efficient implementations? This paper addresses this question and presents an overview of techniques for compiling monadic concurrency models directly into reasonably efficient software and hardware implementations. The implementation techniques described in this article form the basis of a semantics-directed approach to model-driven engineering. 1