Results 1 
5 of
5
Dynamically discovering likely program invariants to support program evolution
 IEEE Transactions on Software Engineering (TSE
, 2001
"... ..."
Manufacturing Datatypes
, 1999
"... This paper describes a general framework for designing purely functional datatypes that automatically satisfy given size or structural constraints. Using the framework we develop implementations of different matrix types (eg square matrices) and implementations of several tree types (eg Braun trees, ..."
Abstract

Cited by 23 (3 self)
 Add to MetaCart
This paper describes a general framework for designing purely functional datatypes that automatically satisfy given size or structural constraints. Using the framework we develop implementations of different matrix types (eg square matrices) and implementations of several tree types (eg Braun trees, 23 trees). Consider, for instance, representing square n \Theta n matrices. The usual representation using lists of lists fails to meet the structural constraints: there is no way to ensure that the outer list and the inner lists have the same length. The main idea of our approach is to solve in a first step a related, but simpler problem, namely to generate the multiset of all square numbers. In order to describe this multiset we employ recursion equations involving finite multisets, multiset union, addition and multiplication lifted to multisets. In a second step we mechanically derive datatype definitions from these recursion equations which enforce the `squareness' constraint. The tra...
A Hoare Logic for CallbyValue Functional Programs
"... Abstract. We present a Hoare logic for a callbyvalue programming language equipped with recursive, higherorder functions, algebraic data types, and a polymorphic type system in the style of Hindley and Milner. It is the theoretical basis for a tool that extracts proof obligations out of programs ..."
Abstract

Cited by 22 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We present a Hoare logic for a callbyvalue programming language equipped with recursive, higherorder functions, algebraic data types, and a polymorphic type system in the style of Hindley and Milner. It is the theoretical basis for a tool that extracts proof obligations out of programs annotated with logical assertions. These proof obligations, expressed in a typed, higherorder logic, are discharged using offtheshelf automated or interactive theorem provers. Although the technical apparatus that we exploit is by now standard, its application to callbyvalue functional programming languages appears to be new, and (we claim) deserves attention. As a sample application, we check the partial correctness of a balanced binary search tree implementation. 1
Abstract
"... Analysis (CWA) framework) could be applied in requirements engineering. We introduce an existing RE toolkit, the ι * modeling framework, and compare it with the CWA framework. The paper concludes with an outline of opportunities to integrate the techniques of cognitive engineering with those from re ..."
Abstract
 Add to MetaCart
Analysis (CWA) framework) could be applied in requirements engineering. We introduce an existing RE toolkit, the ι * modeling framework, and compare it with the CWA framework. The paper concludes with an outline of opportunities to integrate the techniques of cognitive engineering with those from requirements engineering in the design of complex sociotechnical systems.
Generic and Indexed Programming (Project Paper)
"... The EPSRCfunded Generic and Indexed Programming project will explore the interaction between datatypegeneric programming (DGP) — programs parametrized by the shape of their data — and indexed programming (IP) — lightweight dependentlytyped programming, with programs indexed by typelevel represe ..."
Abstract
 Add to MetaCart
(Show Context)
The EPSRCfunded Generic and Indexed Programming project will explore the interaction between datatypegeneric programming (DGP) — programs parametrized by the shape of their data — and indexed programming (IP) — lightweight dependentlytyped programming, with programs indexed by typelevel representations of properties. Integrating these two notions will provide new ways for programmers to capture abstractions. The project builds on insights from our recent work in DGP, which has investigated both programming techniques (including reasoning about generic programs, and using them to capture design patterns precisely), and language mechanisms (particularly lightweight approaches: patterns for simulating highlyexpressive techniques in familiar but apparently lessexpressive languages). Firstly, these lightweight techniques, which we have been embedding in Haskell’s still relatively expressive type system, are in fact applicable to even less expressive but more popular mainstream languages such as Java and C#. Secondly, the techniques are more applicable than we first thought; in particular, they offer a solution to the socalled ‘expression problem’: safe combination of independent extensions along multiple dimensions. Thirdly, there is a synergy between DGP and IP: DGP makes IP more appealing, because the effort of stating properties can be amortized over more programs; IP provides a mechanism for DGP, because the indices can be representations of data’s shape. 1