We present our work on the representation and correctness of program schemas, in the context of logic program synthesis. Whereas most researchers represent schemas purely syntactically as higher-order expressions, we shall express a schema as an open first-order theory that axiomatises a problem domain, called a specification framework, containing an open program that represents the template of the schema. We will show that using our approach we can define a meaningful notion of correctness for schemas, viz. that correct program schemas can be expressed as parametric specification frameworks containing templates that are steadfast, i.e. programs that are always correct provided their open relations are computed correctly.

It can be argued that for (semi-)automated software development, program schemas are indispensable, since they capture not only structured program design principles, but also domain knowledge, both of which are of crucial importance for hierarchical program synthesis. Most researchers represent schemas purely syntactically (as higher-order expressions) . This means that the knowledge captured by a schema is not formalised. We take a semantic approach and show that a schema can be formalised as an open (firstorder) logical theory that contains an open logic program. By using a special kind of correctness for open programs, called steadfastness, we can define and reason about the correctness of schemas. We also show how to use correct schemas to synthesise steadfast programs. 1. Introduction It can be argued that any systematic approach to software development must use some kind of schema-based strategies. In (semi-)automated software development, program schemas become indispensable, s...

. Current Object-oriented Design (OOD) methodologies tend to focus on objects as the unit of reuse, but it is increasingly recognised that frameworks, or groups of interacting objects, are a better unit of reuse. Thus, in next-generation Component-based Development (CBD) methodologies, we can expect components to be frameworks rather than objects. In this paper, we describe a preliminary attempt at a formal semantics for OOD frameworks in CBD in computational logic. 1 Introduction Most of the existing (semi-formal) Object-oriented Design (OOD) methods such as Fusion [4, 6] and Syntropy [5] use classes or objects as the basic unit of design or reuse. These methods are based on the traditional view of an object, as shown in Figure 1, which regards an object as a closed entity with one fixed role. visible functions structure internal encapsulated Fig. 1. Traditional view of an object. This, however, does not reflect the nature of objects (and classes that describe them) in practical syst...

In this paper, we specify an open problem: predictable component assembly, and state a position on compositional reasoning techniques that we believe are necessary for this purpose. 1 A Rhetorical Question? Yes, naturally, the question in the title is meant to be rhetorical. However, by formality I do not mean that which is exemplified by existing formal methods. Rather, I mean the use of a priori reasoning, instead of the prevalent a posteriori reasoning used for verification-based software construction. 2 What is A Priori Reasoning? Verification-based methods take the `posit-and-see' approach: given the specification for a program, first posit a program, then see if the program is correct (wrt to the given specification); similarly, to construct a specified composite, first posit the components and their composition, then see if their composition meets the given specification. This is what I call a posteriori reasoning: reasoning about correctness (or other properties) takes place...

We present a formalisation of modules that are correct, and (correctly) reusable in the sense that composition of modules preserves both correctness and reusability. We also introduce a calculus for formally reasoning about the construction of such modules.

There is a general consensus that the paradigm shift to component-based software development should be accompanied by a corresponding paradigm shift in the underlying approach to specification and reasoning. Work in modular specification and verification has shown the way, and following its lead, in this position paper, we outline our approach to specifying and reasoning about components, which uses a novel notion of correctness. 1 What is this paper about? As the title suggests, this paper is about an approach to formal specification of software components. The purpose of such an approach is to allow formal reasoning about components. The ultimate goal of Component-based Software Development (CBD) is third-party assembly. To achieve this, it is necessary to be able to specify components in such a way that we can reason about their construction and composition, and correctness thereof, a priori. Work in modular specification and verification, e.g. [9, 14] has shown the way, and our approach follows its lead. However, our approach is novel and hence different in the way we define correctness. In this paper, we will discuss how we specify components, and in particular how we define and reason about correctness, and why this is useful for CBD. 2 Specifying Components Ideally components should be black boxes, in order that users can (re)use them without knowing the details of their innards. In other words, the interface of a component should provide all the information that users need. Moreover, this information should be the only information that they need. Consequently, the interface of a component should be the

Since the early days of programming and automated reasoning, researchers have developed methods for systematically constructing programs from their specifications. Especially the last decade has seen a flurry of activities including the advent of specialized conferences, such as LOPSTR, covering the synthesis of programs in computational logic. In this paper we analyze and compare three state-of-the-art methods for synthesizing recursive programs in computational logic. The three approaches are constructive/deductive synthesis, schema-guided synthesis, and inductive synthesis. Our comparison is carried out in a systematic way where, for each approach, we describe the key ideas and synthesize a common running example. In doing so, we explore the synergies between the approaches, which we believe are necessary in order to achieve progress over the next decade in this field.

. Various formalizations of the concept of "refinement step" as used in the formal development of programs from algebraic specifications are presented and compared. 1 Introduction Algebraic specification aims to provide a formal basis to support the systematic development of correct programs from specifications by means of verified refinement steps. Obviously, a central piece of the puzzle is how best to formalize concepts like "specification", "program" and "refinement step". Answers are required that are simple, elegant and general and which enjoy useful properties, while at the same time taking proper account of the needs of practice. Here I will concentrate on the last of these concepts, but first I need to deal with the other two. For "program", I take the usual approach of algebraic specification whereby programs are modelled as many-sorted algebras consisting of a collection of sets of data values together with functions over those sets. This level of abstraction is commens...

Quality software must be reusable, extensible and reliable. In computational logic , we have developed an approach to constructing programs that are formally correct. Our approach can provide a basis for constructing software that is (formally) reusable and extensible, and not just reliable but formally correct. In this paper, we explain our notion of correct classes, and how to develop them. 1 Introduction Quality software must be reusable, extensible (or maintainable), and reliable. Object-oriented programming is seen as a suitable programming paradigm for constructing such software. It achieves reusability and extensibility by the use of classes (of objects) with inheritance. Reliability can be gained by verifying assertions which correspond to invariants on classes and pre-post-conditions on their methods. In computational logic, we have developed an approach to constructing programs that are formally correct (wrt their specifications). Our approach is declarative in the sense tha...

. Quality software must be reusable, extensible, and reliable. Object-oriented programming purports to achieve these attributes by the use of classes and inheritance (informally). In this paper, we show how our existing approach to deductive synthesis of logic programs can serve as the basis for an object-oriented methodology for formal program development that achieves reusability, extensibility and correctness (formally). 1 Introduction Object-oriented programming is very much seen as the standard bearer of the software industry nowadays, because it purports to achieve the key attributes of any quality software: reusability , extensibility , and reliability (see e.g. [12, 13]). Object-oriented programming achieves reusability and extensibility by using a class as the basic modular unit, and a mechanism called inheritance to define new classes from existing ones. Reliability results from the ability to monitor assertions and invariants contained in classes. However, at present, th...