Abstract not found

This paper describes ongoing work to establish semantic foundations for real-world distributed computation. We are designing and implementing Acute, an expressive and safe programming language (based on an OCaml core) with features for managing abstraction-safe marshalling, dynamic rebinding, and versioning. These permit user-level communication libraries to be written simply as type-safe Acute code, above TCP/UDP sockets. Further, we are precisely characterizing the properties of TCP and UDP network communication; of particular interest is the semantics of communication failures. Together with the Acute language semantics this constitutes a mathematically precise and executable system for writing distributed communication libraries, P2P algorithms, etc.

Static binding is the standard binding discipline in programming languages. However, the demands of developing distributed, highly dynamic applications have led to an increasing interest in dynamic programming languages and mechanisms. Typically, this needs are satisfied by hoc mechanisms that lack clean semantics. In this paper, we adopt a foundational approach, developing a core dynamic

High-level programming languages For non-distributed, non-concurrent programming, they’re pretty good. We have ML (SML/OCaml), Haskell, Java, C#, with: • type safety • rich concrete types – datatypes and functions • abstraction mechanisms for program structuring – ML modules with abstract types, type classes and monads, classes and objects,... 2 High-level programming languages For non-distributed, non-concurrent programming, they’re pretty good. We have ML (SML/OCaml), Haskell, Java, C#, with: • type safety • rich concrete types – datatypes and functions • abstraction mechanisms for program structuring – ML modules and abstract types, type classes and monads, classes and objects,... But this is only within single executions of single programs. What about distributed computation? 3 Overview In these talks I aim to introduce some of the main problems in designing languages that are just as good for distributed programming as those are for the local, sequential world. For some we have reasonable solutions; others are still open. It’ll be idiosyncratic, not a survey (but with pointers to other work). 4 Challenges (1/2)

This report places the foundational work of PEPITO, the initial work of which was described in Deliverable D1.7 "First Progress Report on Formal Models", in the broad perspective of P2P systems. We begin by recapitulating the characteristics of peer-to-peer systems. We then discuss the nature of foundational work in general, highlighting the different kinds of contribution it can make. The main body of the report, Section 3, discusses the main problem areas in which foundational work is required for systems with the P2P characteristics: techniques for Specification and Correctness of the subtle distributed algorithms that arise in these systems

We present a simple module calculus modeling reconfiguration of code in an open environment, where some software fragments can be provided from the outside and combined with others after execution has started. Software fragments and their composition are modeled as in previous module calculi; here, we focus on the new problems posed by the fact that code fragments are not all available at compile time. In particular, we want to be able to statically check internal consistency of local code, by only specifying a required type for missing code, and then to perform dynamic checks which ensure that code received from the outside, which is assumed to travel with its type, can be successfully accepted, without requiring to type-check the whole code again. We consider

We define a type system with intersection types for an extension of lambda-calculus with unbind and rebind operators. In this calculus, a term t with free variables x1,...,xn, representing open code, can be packed into an unbound term 〈 x1,...,xn | t 〉, and passed around as a value. In order to execute inside code, an unbound term should be explicitly rebound at the point where it is used. Unbinding and rebinding are hierarchical, that is, the term t can contain arbitrarily nested unbound terms, whose inside code can only be executed after a sequence of rebinds has been applied. Correspondingly, types are decorated with levels, and a term has type τ k if it needs k rebinds in order to reduce to a value of type τ. With intersection types we model the fact that a term can be used differently in contexts providing a different numbers of unbinds. In particular, top-level terms, that is, terms not requiring unbinds to reduce to values, should have a value type, that is, an intersection type where at least one element has level 0. With the proposed intersection type system we get soundness under the call-by-value strategy, an issue which was not resolved by previous type systems.

Abstract. We extend the simply typed λ-calculus with unbind and rebind primitive constructs. That is, a value can be a fragment of open code, which in order to be used should be explicitly rebound. This mechanism nicely coexists with standard static binding. The motivation is to provide an unifying foundation for mechanisms of dynamic scoping, where the meaning of a name is determined at runtime, rebinding, such as dynamic updating of resources and exchange of mobile code, and delegation, where an alternative action is taken if a binding is missing. Depending on the application scenario, we consider two extensions which differ in the way type safety is guaranteed. The former relies on a combination of static and dynamic type checking. That is, rebind raises a dynamic error if for some variable there is no replacing term or it has the wrong type. In the latter, this error is prevented by a purely static type system, at the price of more sophisticated types. 1991 Mathematics Subject Classification. 68N15, 68N18.

High-level programming language design for distributed computation Design rationale and language definition

High-level programming language design for distributed computation Design rationale and language definition