Problem solving methods (PSMs) are domain-independent reasoning components, which specify patterns of behavior which can be reused across applications. While the availability of extensive PSM libraries and the emerging consensus on PSM specification languages indicate the maturity of the field, a number of important research issues are still open. In particular, very little progress has been achieved on foundational and methodological issues. Existing libraries of PSMs lack a clear theoretical basis and only provide weak support for the method development process, usually in the form of informal guidelines. In this paper we will address these issues by illustrating a framework which characterizes PSMs in terms of problem commitments, problem-solving paradigms and domain assumptions. This framework provides i) a theoretical foundation for situating PSM research and individual PSMs, as well as ii) an organization which allows us to characterize method development and selection as a process of navigating through a three-dimensional space (defined by the three components of our framework). Individual moves through this space are specified by means of adapters. In the paper we will illustrate these ideas in detail, with examples taken from parametric design problem solving. 1.

We present an overview of the program transformation methodology, focusing our attention on the so-called `rules + strategies' approach in the case of functional and logic programs. The paper is intended to offer an introduction to the subject. The various techniques we present are illustrated via simple examples. A preliminary version of this report has been published in: Moller, B., Partsch, H., and Schuman, S. (eds.): Formal Program Development. Lecture Notes in Computer Science 755, Springer Verlag (1993) 263--304. Also published in: ACM Computing Surveys, Vol 28, No. 2, June 1996. 3 1 Introduction The program transformation approach to the development of programs has first been advocated by [Burstall-Darlington 77], although the basic ideas were already presented in previous papers by the same authors [Darlington 72, Burstall-Darlington 75]. In that approach the task of writing a correct and efficient program is realized in two phases: the first phase consists in writing an in...

ion of the Specification Borrowing a saying of Einstein's, I maintain that specifications should be as abstract as possible, but not more abstract. I see three limitations to the degree of abstraction. First, a specification as an adequate formalization of the requirements cannot be more abstract than the requirements themselves. If a specific algorithm is required, this algorithm must be specified. This argument applies as well to non-functional requirements constraining possible implementations. Some constraints can appear as comments in specifications, e.g. the requirement that a specific language should be used for the implementation. Other constraints, however, must be concretely specified, e.g. the requirement that the future software system has to adhere to the data structures of a given interface. The second limitation to abstraction arises when we make formal specifications executable. Even if the degree of abstraction of the data structures and the algorithms stays the same,...

In this paper we describe work in progress concerning the (semi-)automatic support for developing agents. We focus on the scenario in which agents have to be designed to follow an electronic institution. An initial design pattern is automatically extracted from a given electronic institution and oered to programmers willing to develop agents for the speci c purpose of joining and performing in the electronic institution. We resort to logic programming as our underlying computational framework, explaining and justifying this decision.

In this position paper, we give a critical analysis of the deductive and inductive approaches to program synthesis, and of the current research in these fields. From the shortcomings of these approaches and works, we identify future research directions for these fields, as well as a need for cooperation and cross-fertilization between them.

. Schema-based transformational systems maintain a library of logic program schemata which capture large classes of logic programs. One of the shortcomings of schema-based transformation approaches is their reliance on a large (possibly incomplete) set of logic program schemata that is required in order to capture all of the minor syntactic differences between semantically similar logic programs. By defining a set of extensible logic program schemata and an associated set of logic program transformations, it is possible to reduce the size of the schema library while maintaining the robustness of the transformational system. In our transformational system, we have defined a set of extensible logic program schemata in #Prolog. Because #Prolog is a higher-order logic programming language, it can be used as the representation language for both the logic programs and the extensible logic program schemata. In addition to the instantiation of predicate variables, extensible logic program sc...

Schema-based logic program transformation has proven to be an effective technique for the optimisation of programs. This paper results from the research that began by investigating the suggestions in [11] to construct a more general database of transformation schemas for optimising logic programs at the declarative level. The proposed transformation schemas fully automate accumulator introduction (also known as descending computational generalisation), tupling generalisation (a special case of structural generalisation), and duality laws (which are extensions to relational programming of the first duality law of the fold operators in functional programming). The schemas are proven correct. A prototype schema-based transformation system is evaluated.

We introduce the concept of reflection principle as a knowledge representation paradigm in a computational logic setting. Reflection principles are expressed as certain kinds of logic schemata intended to capture the basic properties of the domain knowledge to be modeled. Reflection is then used to instantiate these schemata to answer specific queries about the domain. This differs from other approaches to reflection mainly in the following three ways. First, it uses logical instead of procedural reflection. Second, it aims at a cognitively adequate declarative representation of various forms of knowledge and reasoning, as opposed to reflection as a means for controlling computation or deduction. Third, it facilitates the building of a complex theory by allowing a simpler theory to be enhanced by a compact metatheory, contrary to the construction of metatheories that are only conservative extensions of the basic theory. A computational logic system for embedding reflection principles, called RCL (for Reflective Computational Logic), is presented in full detail. The system is an extension of Horn clause resolution-based logic, and is devised in a way that makes important features of reflection parametric as much as possible, so that they can be tailored according to specific needs of different application domains. Declarative and procedural semantics of the logic are described and correctness and completeness of reflection as logical 1 inference are proved. Examples of reflection principles for three different application areas are shown. Relationship with a variety of distinct sources within the literature on relevant topics is discussed.

This paper should replace a previous work entitled Enhanced Schema-Based Transformations for Logic Programs and their Opportunistic Usage in Program Analysis and Optimisation (Technical Report 95-16, Institut fr Informatik, Universitt Zrich), extending and updating it

In our method -- that we call Visual and Textual Composition of Logic Programs -- we have enhanced the schema-based construction of logic programs in two ways intended to bridge the conceptual gap between application domains and the programming domain. First, we define visual and textual views of programs that can be used to construct programs in application-specific concepts, and which can be understood as executable specifications of the programs being constructed. Second, in addition to schemata for Prolog programming constructs and techniques we introduce a repository of application-specific components. As a further enhancement of the method we have added schema-based transformations to increase the efficiency of the constructed programs. We have implemented both a program development system and a transformation system, and used these systems to develop programs for non-trivial applications like the well-known library data base problem and an automated teller machine. 1 Schema-Base...