The GeoGram system [21]generates programs for geometric computations by combining generic software components as specified by diagrams constructed using a graphical interface. The user specifies known and desired quantities. As diagrams are constructed, the system maintains symbolic geometric facts describing the construction. Inferences based on the diagram are used to derive new facts and to introduce new objects based on geometric reasoning, to filter choices presented to the user, to interpret the user's intention in ambiguous cases, to detect over-specification, and to generate the program. A knowledge base of descriptions of generic software components is used to prove that features of the geometry can be computed from known values. These local proofs are combined to guide generation of a program that computes the desired values from inputs. The library of generic geometric program components is used to generate both in-line code and specialized subroutines; partial evaluation improves the efficiency of the generated code. The resulting program is automatically translated into the desired language. The program can also be run interactively to simulate the geometry by generating graphical traces on the diagram as input quantities are varied.

A generic procedure can be specialized, by compilation through views, to operate directly on concrete data. A view is a computational mapping that describes how a concrete type implements an abstract type. Clusters of related views are needed for specialization of generic procedures that involve several types or several views of a single type. A user interface that reasons about relationships between concrete types and abstract types allows view clusters to be created easily. These techniques allow rapid specialization of generic procedures for applications.

Algorithms are presented for converting units of measurement from a given form to a desired form. The algorithms are fast, are able to convert any combination of units to any equivalent combination, and perform dimensional analysis to ensure that the conversion is legitimate. Algorithms are also presented for simplification of symbolic combinations of units. Application of these techniques to perform automatic unit conversion and unit checking in a programming language is described.>

Software reuse is inhibited by the many different ways in which equivalent data can be represented. We describe methods by which views can be constructed semi-automatically to describe how application data types correspond to the abstract types that are used in numerical generic algorithms. Given such views, specialized versions of the generic algorithms that operate directly on the application data can be produced by compilation. This enables reuse of the generic algorithms for an application with minimal effort. Graphical user interfaces allow views to be specified easily and rapidly. Algorithms are presented for deriving, by symbolic algebra, equations that relate the variables used in the application data to the variables needed for the generic algorithms. Arbitrary application data structures are allowed. Units of measurement are converted as needed. These techniques allow reuse of a single version of a generic algorithm for a variety of possible data representations and programming languages. These techniques can also be applied in data conversion and in object-oriented, functional, and transformational programming.

A significant barrier to the reuse of software is the rigid interface presented by a subroutine. For nontrivial data structures, it is unlikely that the existing form of the data of an application will match the requirements of a separately written subroutine. The authors describe two methods of interfacing existing data to a subroutine: generation of a program to convert the data to the form needed by the subroutine, and rewriting the subroutine, through compilation, to fit the existing data. Both methods can be invoked through easily used menu-based negotiation with the user. These methods have been implemented using the GLISP language and compiler.>

A new dimension of object-oriented components is presented to describe knowledge-level models of an application. From the knowledge-level perspective, components are needed for modeling the problems, solution methods, and their relationships in a problem-solving process. A problem can often be decomposed recursively by various methods into subproblems until reaching primitive ones. Each primitive problem is confined to a simple computational task, which can be solved by one problem-solving method. The process of problem solving is viewed as a modeling activity through explicitly represented knowledge-level models that are, then, operationalized. Design issues that are encountered when developing such a component-based framework for knowledge-level modeling are described.>

A computer program, APEX, is proposed to investigate idealized formal models representing physics problems. Two types of models are defined: canonical physical objects and physical models. During problem solving, the problem is represented as a data connection network, which is progressively augmented by these models in the form of additional network elements. APEX employs views as a representational framework for connecting the initially informal objects to the formal models of the domain. The view framework supports multiple representations (e.g., viewing many objects as a single canonical physical object), handling of incompletely specified problems, and invertibility of the views. This computational framework provides a powerful representational mechanism that allows a finite set of physical principles to be applied to a potentially infinite variety of problems. As a knowledge engineering technique, views allow general principles to be applied to a variety of objects whose representations differ.>