Untyped Model Research Articles

Constraint programming for type inference in flexible model-driven engineering

Domain experts typically have detailed knowledge of the concepts that are used in their domain; however they often lack the technical skills needed to translate that knowledge into model-driven engineering (MDE) idioms and technologies. Flexible or bottom-up modelling has been introduced to assist with the involvement of domain experts by promoting the use of simple drawing tools. In traditional MDE the engineering process starts with the definition of a metamodel which is used for the instantiation of models. In bottom-up MDE example models are defined at the beginning, letting the domain experts and language engineers focus on expressing the concepts rather than spending time on technical details of the metamodelling infrastructure. The metamodel is then created manually or inferred automatically. The flexibility that bottom-up MDE offers comes with the cost of having nodes in the example models left untyped. As a result, concepts that might be important for the definition of the domain will be ignored while the example models cannot be adequately re-used in future iterations of the language definition process. In this paper, we propose a novel approach that assists in the inference of the types of untyped model elements using Constraint Programming. We evaluate the proposed approach in a number of example models to identify the performance of the prediction mechanism and the benefits it offers. The reduction in the effort needed to complete the missing types reaches up to 91.45% compared to the scenario where the language engineers had to identify and complete the types without guidance.

A Graph Model for Imperative Computation

Scott's graph model is a lambda-algebra based on the observation that continuous endofunctions on the lattice of sets of natural numbers can be represented via their graphs. A graph is a relation mapping finite sets of input values to output values. We consider a similar model based on relations whose input values are finite sequences rather than sets. This alteration means that we are taking into account the order in which observations are made. This new notion of graph gives rise to a model of affine lambda-calculus that admits an interpretation of imperative constructs including variable assignment, dereferencing and allocation. Extending this untyped model, we construct a category that provides a model of typed higher-order imperative computation with an affine type system. An appropriate language of this kind is Reynolds's Syntactic Control of Interference. Our model turns out to be fully abstract for this language. At a concrete level, it is the same as Reddy's object spaces model, which was the first "state-free" model of a higher-order imperative programming language and an important precursor of games models. The graph model can therefore be seen as a universal domain for Reddy's model.

A Precise Yet Efficient Memory Model For C

Verification for OO programs typically starts from a strongly typed object model in which distinct objects/fields are guaranteed not to overlap. This model simplifies verification by eliminating all “uninteresting” aliasing and allowing the use of more efficient frame axioms. Unfortunately, this model is unsound and incomplete for languages like C, where “objects” can overlap almost arbitrarily. Sound verification for C therefore typically starts from an untyped memory model, where memory is just an array of bytes. The untyped model, however, adds substantial annotation burden, and reasoning in the untyped model is computationally expensive.We propose a sound, typed semantics for C that provides the annotational and computational advantages of the typed object model while remaining sound and complete for C. We maintain a predicate identifying where the “valid” objects are, and introduce invariants and proof obligations that guarantee that the valid objects are suitably antialiased, and that (almost) all objects appearing in the program are valid. We describe the implementation of this approach in VCC (a sound verifier for C being used to verify the Microsoft Hypervisor) and the resulting performance gains.

Preface: Volume 69

This volume contains the proceedings of the 9th Conference on Category Theory and Computer Science (CTCS'02), which was held at the University of Ottawa from August 15-17, 2002. The purpose of this conference series is the advancement of the foundations of computing using the tools of category theory. Indeed, category theory provides one of the key tools in the analysis of the interaction between logic and the theory of computation. The extent to which category theory has influenced these areas can be seen from the following list of topics, which are typical of the interests of this conference: • coalgebras and computing • concurrent and distributed systems • constructive mathematics • declarative programming and term rewriting • domain theory and topology • foundations of computer security • linear logic • modal and temporal logics • models of computation • program logics, data refinement, and specification • programming language semantics • type theory The list is by no means exhaustive. The vitality of the field is well displayed by the extremely high quality and the diversity of the 18 papers in this volume. For the first time in the history of CTCS, this year's conference was preceded by a “Graduate Student Preconference”, which took place from August 12-14 and which offered introductory courses in areas of importance to the conference. The response to this preconference was extraordinary, with more than 50 students and interested others taking part. This certainly suggests that the field of research of this conference will be strong and active for many years to come. The preconference offered courses in: • Introductory category theory (Susan Niefield) • Categorical logic (Philip Scott) • Concurrency theory (Peter Selinger) • Coalgebraic methods (Jiri Adamek) • Game theory (Robin Cockett) • Linear logic (Rick Blute) To hold this preconference, we received substantial funding from the Centre de Recherches Mathematiques (CRM). We thank them and Jacques Hurtubise, the Director of CRM, for their kind support. Without the help of many individuals in many different capacities, this conference would not have been possible. The editors would especially like to thank the following people: • The organizing committee: ◦ E. Moggi, Chair, (Genova) ◦ S. Abramsky (Oxford) ◦ P. Dybjer (Chalmers) ◦ B. Jay (Sydney) ◦ A. Pitts (Cambridge) • Local organizers: ◦ Rick Blute ◦ Philip Scott • The programme committee: ◦ Rick Blute, Chair (Ottawa) ◦ Robin Cockett (Calgary) ◦ Thierry Coquand (Chalmers) ◦ Andrea Corradini (Pisa) ◦ Thomas Ehrhard (Luminy) ◦ Ryu Hasegawa (Tokyo) ◦ Martin Hofmann (Munich) ◦ Bart Jacobs (Nijmegen) ◦ Michael Johnson (Macquarie) ◦ Dusko Pavlovic (Kestrel Institute) ◦ Alex Simpson (Edinburgh) • Lecturers in the student preconference: ◦ Susan Niefield (Union) ◦ Philip Scott (Ottawa) ◦ Robin Cockett (Calgary) ◦ Rick Blute (Ottawa) ◦ Jiri Adamek (Braunschweig) ◦ Peter Selinger (Ottawa)

Heap-Bounded Assembly Language

We present a first-order linearly typed assembly language, HBAL, that allows the safe reuse of heap space for elements of different types. Linear typing ensures the single pointer property, disallowing aliasing but allowing safe, in-place-update compilation of programming languages. We prove that HBAL is sound for a low-level untyped model of the machine, using a satisfiability relation that captures when a location correctly models a value of some type. This interpretation is closer to the machine than previous abstract machines used for typed assembly language models, and we separate typing of the store from an untyped operational semantics of programs, as would be required for proof-carrying code. Our ultimate aim is to design a family of assembly languages that have high-level typing features for expressing resource-bound constraints. We want to link the assembly-level with high-level languages expressing similar constraints, to provide end-to-end guarantees and a viable framework for proof-carrying code. HBAL is a first exemplifying step in this direction. It is designed as a target low-level language for Hofmann's LFPL language. Programs written in LFPL run in a bounded amount of heap space, and this property carries over when they are compiled to HBAL: the resulting program does not allocate store or assume an external garbage collector. Following LFPL, we include a special diamond resource type that stands for a unit of heap space of uncommitted type.