We describe a variant of the Standard ML programming language which incorporates a facility for the replacement of modular components during program execution. This useful extension of the language builds upon existing compiler technology which permits the separate compilation of modular units of a Standard ML program. Defined naively, this extension would incur performance overheads due to the need to retain typing information at run-time. Here we explain how this cost can be significantly lessened and in some cases eliminated entirely. The essential technical device which we employ for implementation of our extension to the language is a modification of two-space copying garbage collection. Keywords: languages modular programming; static type checking; dynamic 1

In this dissertation I argue that modal type systems provide an elegant and practical means for controlling local resources in spatially distributed computer programs. A distributed program is one that executes in multiple physical or logical places. It usually does so because those places have local resources that can only be used in those locations. Such resources can include processing power, proximity to data, hardware, or the physical presence of a user. Programmers that write distributed applications therefore need to be able to reason about the places in which their programs will execute. This work provides an elegant and practical way to think about such programs in the form of a type system derived from modal logic. Modal logic allows for reasoning about truth from multiple simultaneous perspectives. These perspectives, called "worlds," are identified with the locations in the distributed program. This enables the programming language to be simultaneously aware of the various hosts involved in a program, their

Abstract. Modern software design has embraced components. Developers who exploit the associated tools and strongly-typed object-oriented languages can be more productive. However, existing tools don’t go as far as they could with respect to distributed applications. These are often tightly coupled to complex underlying communication substrates and require that developers work through procedure-call APIs, even when using modern SOA platforms. We propose a new application development paradigm and a platform, in which instances of distributed protocols are modeled as “live distributed objects”. Live objects can represent both protocols and higher-level components. They look and feel much like ordinary objects, but can maintain shared state and synchronization across multiple different machines within a network. Live objects can be composed in a type-safe manner to build sophisticated distributed applications using a simple, intuitive “drag and drop ” interface, very often without writing any code or having to understand the intricacies of the underlying distributed algorithms. 1

Abstract not found

. The idea of making synchronous operations into first-class values is an important one for supporting abstraction and modularity in concurrent programs. This design principle has been used with great success in the concurrent language CML, but what are the limitations of this approach? This paper explains the rationale for first-class synchronous operations, and discusses their use in CML. It also presents some recent and fundamental results about the expressiveness of rendezvous primitives, which define the limitations of synchronous abstractions. 1 Introduction Abstraction is a key tool for managing complexity. The design of programming languages is one area where application of this idea has paid significant dividends. Languages have evolved from providing a fixed set of abstractions of the underlying hardware, such as arithmetic expressions and arrays, to providing support for programmer-defined abstractions, such as abstract data-types and higher-order procedures. By providing ...

This paper presents a new object-oriented approach to modeling the semantics of distributed multi-party protocols such as leader election, distributed locking, or reliable multicast, and a programming language that supports it. The approach builds on and extends our live distributed objects model [37] by introducing a new concept of a distributed flow, a stream of messages flowing concurrently at multiple locations. Our flows correspond to variables, private fields, and method parameters in Java-like languages; they are the means by which we store and communicate state. Active protocol instances, which correspond to Java objects, consume and output flows; their internal states are encapsulated as internal flows, and all of their internal logic is represented as operations on flows. Our language supports a new type of concern separation:

This thesis describes the design and implementation of VuDP, a programming system for distributed media applications. VuDP has been implemented as a set of extensions to the VuSystem, a programming environment for media-based applications. VuDP supports distributed media applications in whichVuSystem modules can be created and placed on any node in a network. VuDP is integrated with the VuSystem runtime programming environment and dynamic reconfiguration capabilities. VuDP has been used to develop several VuSystem applications that would have been difficult or impossible to implement without the VuDP extensions. The VuDP remote evaluation mechanism allows for the creation and manipulation of remote interpreters and for setting up both in-band (media flow) and out-of-band (control and event handling) connections between local and remote interpreters. Further, VuDP RPC mechanisms complement remote evaluation by providing tools and services that support the implementation of interactive multi-user applications using the VuDP daemon.

In this chapter, we discuss a widely used fault-tolerant data replication model called virtual synchrony. The model responds to two kinds of needs. First, there is the practical question of how best to embed replication into distributed systems. Virtual synchrony defines dynamic process groups that have self-managed membership. Applications can join or leave groups at will: a process group is almost like a replicated variable that lives in the network. The second need relates to performance. Although state machine replication is relatively easy to understand, protocols that implement state machine replication in the standard manner are too slow to be useful in demanding settings, and are hard to deploy in very large data centers of the sort seen in today’s cloud-computing environments. Virtual synchrony implementations, in contrast, are able to deliver updates at the same data rates (and with the same low latencies) as IP multicast: the fast (but unreliable) Internet multicast protocol, often supported directly by hardware. The trick that makes it possible to achieve these very high levels of performance is to hide overheads by piggybacking extra information on regular messages that carry updates. The virtual synchrony

This paper presents a new object-oriented (OO) approach to modeling the semantics of distributed multi-party protocols such as leader election, distributed locks or reliable multicast, and a programming language that supports it. The approach extends our live distributed objects (LO) model with the new concept of a distributed flow (DF), a stream of events that flow concurrently at multiple locations. DFs correspond to local variables, private fields,and method parameters in Java-like languages; they’re means by which one stores and communicates state. Protocol instances correspond to Java objects; they consume and output flows; their internal states are encapsulated as internal flows, and their internal logic is represented as operations on flows. Our language provides a new type of concern separation: the semantic structure of protocols is decoupled from implementation details such as construction and maintenance of overlays, trees, and other structures used for scalability. These can be generated by the compiler or at deployment time. This can be done differently in different parts of the network, to match the local environment.

We describe a variant of the Standard ML programming language which incorporates a facility for the replacement of modular components during program execution. This useful extension of the language builds upon existing compiler technology which permits the separate compilation of modular units of a Standard ML program. Defined naively, this extension would incur performance overheads due to the need to retain typing information at run-time. Here we explain how this cost can be significantly lessened and in some cases eliminated entirely. The essential technical device which we employ for implementation of our extension to the language is a modification of two-space copying garbage collection. Keywords: modular programming; static type checking; dynamic languages 1 Introduction Standard ML is a reliable and useful programming language which provides the expressivity of a functional programming language in a setting where the full power of imperative programming constructs ...