Acute: High-level programming language design for distributed computation

Abstract

Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programminglanguage support for such systems, focussing on their typing and naming issues.We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility.These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.

Function passing: a model for typed, distributed functional programming

“…Acute ML (Sewell et al 2007) is a dialect of ML which proposes numerous primitives for distributed programming, such as type-safe serialization, dynamic linking and rebinding, and versioning. The function passing model, in contrast, is based on spores, which ship with their serialized environment or they fail to compile, obviating the need for dynamic rebinding.…”

Programmable Diagnostic Network Measurement with Localization and Traffic Observation

“…Localization techniques have also been well explored (e.g., [17,20]). Where the XPLANE differs is in its easy to program semantics and novel transformation which preserves those semantics while linearizing execution and localization.…”

On the discriminating power of passivation and higher-order interaction

“…The semantics of passivation has been the subject of a number of papers, usually in extensions of the Higher-Order π-calculus [15,[19][20][21]24]. Passivation is also featured in the Homer calculus [10] and the M-calculus [26]; a similar construct appears in the Seal calculus [4] and in Acute [29]. Passivation has also been advocated to support run-time system updates, fault recovery and fault tolerance (by providing the basis for mechanisms for checkpointing computations and replicating them), and to support adaptive behaviours.…”