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

A spatial logic for concurrency--II

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.

A Basic Model of Typed Components

In addition to behavioral properties, spatial logics can talk about other key properties of concurrent systems such as secrecy, freshness, usage of resources, and distribution. We study an expressive spatial logic for systems specified in the synchronous π-calculus with recursion, based on a small set of behavioral and spatial observations. We give coinductive and equational characterizations of the equivalence induced on processes by the logic, and conclude that it strictly lies between structural congruence and strong bisimulation. We then show that model-checking is decidable for a useful class of processes that includes the finite-control fragment of the π-calculus.

https://link.springer.com/content/pdf/10.1007%2F978-3-540-24727-2_7.pdf

Behavioral and Spatial Observations in a Logic for the π-Calculus

In prior work we proposed an interpretation of intuitionistic linear logic propositions as session types for concurrent processes. The type system obtained from the interpretation ensures fundamental properties of session-based typed disciplines--most notably, type preservation, session fidelity, and global progress. In this paper, we complement and strengthen these results by developing a theory of logical relations. Our development is based on, and is remarkably similar to, that for functional languages, extended to an (intuitionistic) linear type structure. A main result is that well-typed processes always terminate (strong normalization). We also introduce a notion of observational equivalence for session-typed processes. As applications, we prove that all proof conversions induced by the logic interpretation actually express observational equivalences, and explain how type isomorphisms resulting from linear logic equivalences are realized by coercions between interface types of session-based concurrent systems.

https://link.springer.com/content/pdf/10.1007%2F978-3-642-28869-2_27.pdf

Linear logical relations for session-based concurrency

Prior work has shown that intuitionistic linear logic can be seen as a
session-type discipline for the pi-calculus, where cut reduction in
the sequent calculus corresponds to synchronous process reduction. In
this paper, we exhibit a new process assignment from the asynchronous,
polyadic pi-calculus to exactly the same proof rules. Proof-theoretically, the difference between these interpretations can
be understood through permutations of inference rules that preserve
observational equivalence of closed processes in the synchronous case.
We also show that, under this new asynchronous interpretation, cut
reductions correspond to a natural asynchronous buffered session
semantics, where each session is allocated a separate communication
buffer.

/pdf/cut-reduction-in-linear-logic-as-asynchronous-session-typed-3mjqezf9j3.pdf

Luís Caires

Papers

A spatial logic for concurrency--II

A Basic Model of Typed Components

Behavioral and Spatial Observations in a Logic for the π-Calculus

Linear logical relations for session-based concurrency

Cut Reduction in Linear Logic as Asynchronous Session-Typed Communication