Cun Xiao

Adaptive object-oriented programming using graph-based customization

Object-oriented programs are easier to extend than programs which are not written in an object-oriented style, but object-oriented programs are still very rigid and hard to adapt and maintain. In this article, we introduce adaptive object-oriented programming as an extension to conventional object-oriented programming. Adaptive object-oriented programming facilitates expressing the elements-classes and methods-that are essential to an application by avoiding to make a commitment on the particular class structure of the application. Adaptive programs are speciied using propagation patterns which specify sets of related constraints on class structures. An adaptive program denotes an entire family of programs, as many programs as there are class structures which satisfy its constraints. A class structure which satisses the constraints of an adaptive program is said to customize the program. Adaptive programming, realized by the use of propagation patterns, ooers a new paradigm, extending the object-oriented paradigm by lifting programming to a higher level of abstraction.

Object-oriented software evolution

The authors review propagation patterns for describing object-oriented software at a higher level of abstraction than one used by todays programming languages. A propagation pattern defines a family of programs from which one can select a member by giving a class dictionary graph that details the structure of behavior through part-of and inheritance relationships between classes. Three concepts are introduced: evolution histories, growth-plans and a propagation-directive calculus. Evolution histories describe a sequence of development phases of an object-oriented program, each phase being executable and therefore testable. To keep the programs flexible and short, they are described in terms of propagation patterns. Each phase of an evolution history is tested in small steps that are constrained by class dictionary graphs belonging to a growth-plan. Propagation directives are useful for describing both propagation patterns and growth-plans and are therefore endowed with sufficient expressiveness by being given a formal calculus applicable to object-oriented programming in general. A propagation directive is a succinct description of a family of submodels for a given family of data models. >

Efficient implementation of adaptive software

Adaptive programs compute with objects, just like object-oriented programs. Each task to be accomplished is specified by a so-called propagation pattern which traverses the receiver object. The object traversal is a recursive descent via the instance variables where information is collected or propagated along the way. A propagation pattern consists of (1) a name for the task, (2) a succinct specification of the parts of the receiver object that should be traversed, and (3) code fragments to be executed when specific object types are encountered. The propagation patterns need to be complemented by a class graph which defines the detailed object structure. The separation of structure and behavior yields a degree of flexibility and understandability not present in traditional object-oriented languages. For example, the class graph can be changed without changing the adaptive program at all. We present an efficient implementation of adaptive programs. Given an adaptive program and a class graph, we generate an efficient object-oriented program, for example, in C++. Moreover, we prove the correctness of the core of this translation. A key assumption in the theorem is that the traversal specifications are consistent with the class graph. We prove the soundness of a proof system for conservatively checking consistency, and we show how to implement it efficiently.

Formal foundations for object-oriented data modeling

Class dictionary graphs, axiomatic definitions of basic structures used by object-oriented designers and programmers during the software development process, are discussed. An axiomatic foundation for object-oriented data modeling and efficient algorithms for checking whether a given data model satisfies the axioms are presented. The data model is the foundation for a number of techniques for developing object-oriented systems, including adaptive software, schema abstraction from object examples, schema optimization, planning techniques for system development, and the Law of Demeter, among others. >

Object-Extending Class Transformations

Reorganisation and evolution of class hierarchies is important for object-oriented system development and has received considerable attention in the literature. The contributions of this paper are: (1) a formal study of a set of extension relations and transformations on class hierarchies; (2) a presentation of a small set of primitive transformations which form a minimal and complete basis for the extension relations; and (3) an analysis of the impact of these transformations at the object level.The study leads to a better understanding of evolution and reuse of object-oriented software and class hierarchies. It also provides a terminology and a means of classification for design reuse. The theory presented in this paper is based on the Demeter data model, which gives a concise mathematical foundation for classes and their inheritance and part-of relationships. Parts of the theory have been implemented in the Demeter SystemTM C++, a CASE tool for object-oriented design and programming.

Minimizing Dependency on Class Structures with Adaptive Programs

Adaptive software is a new kind of generic software which attempts to minimize and localize dependency on the context in which the software will be used. An adaptive program is written in terms of constraints on the customizing context in which the program may be used. The constraints are written so that they only encode necessary dependencies and at the same time they localize information on groups of collaborating classes.

Customizing adaptive software to object-oriented software using grammars

Although numerous researchers have pointed out that object-oriented software is easier to extend than software that is not written in an object-oriented style, object-oriented software is still rigid to adapt and maintain. This paper builds on an extension of object-oriented programming which is called adaptive programming. Adaptive programming allows the programmer to write more extensible software called adaptive software without committing to a specific input language. After writing an adaptive program, the programmer selects a specific input language and partially evaluates the program into an executable program. This paper formally studies class dictionaries and informally describes how adaptive programs are partially evaluated by freezing class dictionaries. A class dictionary is mapped into classes of an object-oriented programming language, for example, C++, CLOS etc. A class dictionary defines both a set of objects and a set of sentences (a language). We derive a set of restrictions on class dictionaries which permit a simple printing algorithm and its inverse, a parsing algorithm, to be bijection functions between objects and sentences of the same class. We review propagation patterns for describing adaptive object-oriented software at a higher level of abstraction than the one used by today’s object-oriented programming languages. A propagation pattern is an adaptive program which defines a family of programs. From the family, we can select a member by choosing a class dictionary. The theory presented in this paper has been successfully implemented and used in the Demeter Tools/C++. The system consists of a set of tools that facilitate software evolution.

Experience with a graph-based propagation programming tool

A graph-based tool for object-oriented programming, referred to as propagation patterns, has been developed as part of the Demeter system. The Demeter system consists of the programming language independent Demeter method and a suite of platform-specific Demeter tools. Propagation patterns use a technique based on propagation within a graph to specify groups of collaborating classes. Experience has shown that the propagation pattern tool reduces development effort and makes software easier to engineer and reuse. The Demeter system is introduced, the propagation pattern technique for software engineering is described within the context of the Demeter system, and experience in the use of propagation patterns is summarized.<<ETX>>