Semantic and Logical Properties of Stateful Programming (2002)
| Citations: | 5 - 1 self |
BibTeX
@MISC{Calcagno02semanticand,
author = {Cristiano Calcagno},
title = {Semantic and Logical Properties of Stateful Programming},
year = {2002}
}
Bookmark
 |
 |
 |
 |
 |
 |
OpenURL
Abstract
This thesis studies various aspects of the theory of programming languages with imperative operations on a global store. In Part I we present and study a number of problems that arise when reasoning about imperative languages with pointers, with special emphasis on program logic in the style of Hoare. Firstly, we identify the major sources of difficulty as aliasing and dangling pointers, and examine the device of component substitution (dating back to Morris) to address them; a novel use of component substitution allows us to devise axioms for operations that allocate and dispose of memory. Secondly, we analyze the subtle interaction between pointer logics and garbage collection, addressing an observation by Reynolds that most existing logics for pointers are incompatible with the presence of a garbage collector. Our main results include an analysis of propositions that are garbage insensitive, soundness of Hoare logic rules for a garbage collecting semantics, and full abstraction results connecting partial and total correctness to two natural notions of observational equivalence between programs. Part II is dedicated to the study of a particular formalism for automatic memory management: the region calculus of Tofte and Talpin. The calculus is intuitively simple, yet deceptively subtle, and previous theoretical analyses have been frustratingly complex: no analysis has revealed and explained in simple terms the connection between the subtleties of the calculus and the imperative features it builds on. We propose two approaches, simpler than previous ones, for proving type safety. The first approach is based on the idea of stratified semantics: a high-level semantics dealing with the conceptual issues of the calculus, and a low-level one to remain close to the actual implementation; high-level type safety is easy, and an appropriate relation between the two semantics implies type safety of the low-level one. The second approach is about proving type safety directly, avoiding the burden of having two semantics at the expense of a bit of extra complexity. This second approach appears to be very flexible, as demonstrated by the extension to a region calculus with destructive operations on an explicit store. Part III is a study of multi-staged programming – a paradigm providing support for building, combining and executing code at runtime – in the presence of ML-style references. In previous work, a notion of closed-code constructor was introduced to ensure the absence of free variables in the code being executed. Our main contribution here is the introduction of the notion of closed type as a generalization of closed type-constructor. The main property is that values of closed type are not necessarily closed, but their free variables must be dead code. The main technical results are type safety, and conservative extension with respect to a conventional language with only one stage.
Citations
No citations identified.
