In joint work with Peter O'Hearn and others, based on early ideas of Burstall, we have developed an extension of Hoare logic that permits reasoning about low-level imperative programs that use shared mutable data structure. The simple imperative programming language is extended with commands (not expressions) for accessing and modifying shared structures, and for explicit allocation and deallocation of storage. Assertions are extended by introducing a "separating conjunction" that asserts that its subformulas hold for disjoint parts of the heap, and a closely related "separating implication". Coupled with the inductive definition of predicates on abstract data structures, this extension permits the concise and flexible description of structures with controlled sharing. In this paper, we survey the current development of this program logic, including extensions that permit unrestricted address arithmetic, dynamically allocated arrays, and recursive procedures. We also discuss promising future directions.

/pdf/separation-logic-a-logic-for-shared-mutable-data-structures-1oyj7ddi1a.pdf

Separation logic: a logic for shared mutable data structures

[서평]「Component Software」 - Beyond Object-Oriented Programming -

コンピュータ・サイエンス : ACM computing surveys

Microservices is an architectural style inspired by service-oriented computing that has recently started gaining popularity. Before presenting the current state of the art in the field, this chapter reviews the history of software architecture, the reasons that led to the diffusion of objects and services first, and microservices later. Finally, open problems and future challenges are introduced. This survey primarily addresses newcomers to the discipline, while offering an academic viewpoint on the topic. In addition, we investigate some practical issues and point out a few potential solutions.

/pdf/microservices-yesterday-today-and-tomorrow-30wvjeeix0.pdf

Microservices: Yesterday, Today, and Tomorrow

The Art of Multiprocessor Programming

Throughout the years, several typing disciplines for the π-calculus have been proposed. Arguably, the most widespread of these typing disciplines consists of session types. Session types describe the input/output behaviour of processes and traditionally provide strong guarantees about this behaviour (i.e. deadlock-freedom and fidelity). While these systems exploit a fundamental notion of linearity, the precise connection between linear logic and session types has not been well understood. This paper proposes a type system for the π-calculus that corresponds to a standard sequent calculus presentation of intuitionistic linear logic, interpreting linear propositions as session types and thus providing a purely logical account of all key features and properties of session types. We show the deep correspondence between linear logic and session types by exhibiting a tight operational correspondence between cut-elimination steps and process reductions. We also discuss an alternative presentation of linear session types based on classical linear logic, and compare our development with other more traditional session type systems.

/pdf/linear-logic-propositions-as-session-types-1g3zbawwcn.pdf

Linear Logic Propositions as Session Types

We present a logic that can express properties of freshness, secrecy, structure, and behavior of concurrent systems. In addition to standard logical and temporal operators, our logic includes spatial operations corresponding to composition, local name restriction, and a primitive freshname quantifier. Properties can also be defined by recursion; a central theme of this paper is then the combination of a logical notion of freshness with inductive and coinductive definitions of properties.

A Spatial Logic for Concurrency

We present a process-calculus model for expressing and analyzing service-based systems. Our approach addresses central features of the service-oriented computational model such as distribution, process delegation, communication and context sensitiveness, and loose coupling. Distinguishing aspects of our model are the notion of conversation context, the adoption of a context sensitive, message-passing-based communication, and of a simple yet expressive mechanism for handling exceptional behavior. We instantiate our model by extending a fragment of the π-calculus, illustrate its expressiveness by means of many examples, and study its basic behavioral theory; in particular, we establish that bisimilarity is a congruence.

/pdf/the-conversation-calculus-a-model-of-service-oriented-o3spoz2153.pdf

The conversation calculus: a model of service-oriented computation

In prior research we have developed a Curry-Howard interpretation of linear sequent calculus as session-typed processes. In this paper we uniformly integrate this computational interpretation in a functional language via a linear contextual monad that isolates session-based concurrency. Monadic values are open process expressions and are first class objects in the language, thus providing a logical foundation for higher-order session typed processes. We illustrate how the combined use of the monad and recursive types allows us to cleanly write a rich variety of concurrent programs, including higher-order programs that communicate processes. We show the standard metatheoretic result of type preservation, as well as a global progress theorem, which to the best of our knowledge, is new in the higher-order session typed setting.

/pdf/higher-order-processes-functions-and-sessions-a-monadic-4j2qz6thk1.pdf

Higher-Order processes, functions, and sessions: a monadic integration

This paper studies specific language level abstractions for component-based programming. We propose a simple model which captures some basic ingredients - like explicit context dependence, dynamic binding and subtype polymorphism, late (dynamic) composition, and avoidance of inheritance in favor of object composition - that several authors have defended to be central to black-box object-oriented component programming styles. The model is expressed by a core imperative typed calculus, in which components are first-class entities, and whose basic constructs enable the composition, scripting, instantiation and definition of atomic components. Some motivating programming examples are presented, and the operational semantics is shown to enjoy a type-safety property. We also discuss an extension to the Java language aimed at supporting the proposed model, and some implementation issues.

Luís Caires

Papers

Linear Logic Propositions as Session Types

A Spatial Logic for Concurrency

The conversation calculus: a model of service-oriented computation

Higher-Order processes, functions, and sessions: a monadic integration

A basic model of typed components