Our research has focused on identifying techniques to develop software that is amenable to refactoring and change. The Law of Demeter (LoD) was one contribution in this effort. But it led to other problems. With the current state of the art focused on aspect-oriented software development (AOSD), it is useful to revisit the general objectives of the LoD and adapt it to the new ideas. Hence we introduce the Law of Demeter for Concerns and discuss the important intersection of these approaches with traversals. We explore the ramifications of the Laws of Demeter (LoD and LoDC) to achieve better separation of concerns through improved software processes. They are supported by language mechanisms that are implemented using novel applications of automata theory.

Separation of concerns and loose coupling of concerns are important issues in software enginnering. In this paper we show how to separate traversal-related concerns from other concerns, how to loosely couple traversal-related concerns to the structural concern, and how to efficiently implement traversal-related concerns. The stress is on the detailed description of our algorithms and the traversal specifications they operate on.Traversal of object structures is a ubiquitous routine in most types of information processing. Ad hoc implementations of traversals lead to scattered and tangled code and in this paper we present a new approach, called traversal strategies, to succinctly modularize traversals. In our approach traversals are defined using a high-level directed graph description, which is compiled into a dynamic road map to assist run-time traversals. The complexity of the compilation algorithm is polynomial in the size of the traversal strategy graph and the class graph of the given application. Prototypes of the system have been developed and are being successfully used to implement traversals for Java and AspectJ [Kiczales et al. 2001] and for generating adapters for software components. Our previous approach, called traversal specifications [Lieberherr 1992; Palsberg et al. 1995], was less general and less succinct, and its compilation algorithm was of exponential complexity in some cases. In an additional result we show that this bad behavior is inherent to the static traversal code generated by previous implementations, where traversals are carried out by invoking methods without parameters.

Complex behavior often resists clean modularization in object-oriented languages. Aspect-oriented programming tackles this problem by providing flexible module boundaries that can span and partition classes. However, in order to achieve this flexibility, valuable modularity mechanisms, such as encapsulation and external composition, are lost. The ability to separately compile or reason about a modular unit is also compromised. We propose that this tradeoff is not necessary and that by expressing aspects as part of our modules, we can restore the lost modular properties while maintaining aspectual features. As a concrete demonstration, we present the main features of Aspectual Collaborations and show how these interact to combine modularity with aspectual behavior. The expressiveness of Aspectual Collaborations, AspectJ and Hyper/J are compared using a challenge problem, allowing us to estimate the effectiveness of the approach.

New approaches propose to deal with the tangling of logical units by extending the object-oriented language to support module (de)composition along more than one dimension of concern. The tutorial will briefly survey Aspect-Oriented Programming (@@@@ectJ tool), Adaptive Programming (the Demeter tool), and Hyper-dimensional Separation of Concerns (the Hyper/J tool). The primary focus of the tutorial, however, will be on A daptive Plug-and-Play Components (AP&PC) [2, 1].

Computer supported cooperative work (CSCW) has the potential of providing the environment needed for groups of diverse users to cooperate to achieve their common goals. This potential has been under-utilized. One major obstacle is the lack of cooperation between CSCW systems and the underlying network services to accommodate the dynamic behavior of CSCW groups. Multicast routing presents a strong case where current network services are inadequate for the traffic generated in CSCW environments. We demonstrate the need for CSCW-specific multicast routing and present an integrated QoS architecture where a router QoS manager, on behalf of a multicast routing manager, negotiates with host and CSCW-specific QoS managers for efficient resource utilization and guaranteed QoS delivery. The multicast routing manager switches between routing trees or algorithms as guaranteed by the changes in the characteristics and requirements of the CSCW systems running at the hosts. We discuss an aspect-oriented programming approach to the efficient description and flexible implementation of adaptive application and network protocol behavior.

In several works on design methodologies, design patterns, and programming language design, the need for program entities that capture the patterns of collaboration between several classes has been recognized. The idea is that in general the unit of reuse is not a single class, but a slice of behavior affecting a set of collaborating classes. The absence of large-scale components for expressing these collaborations makes object-oriented programs more difficult to maintain and reuse, because functionality is spread over several methods and it becomes difficult to get the "big picture". In this paper, we propose Adaptive Plug and Play Components to serve this need. These components are designed such that they not only facilitate the construction of complex software by making the collaborations explicit, but they do so in a manner that supports the evolutionary nature of both structure and behavior.

A collection of design patterns was described by E. Gamma et al. (1994). Each pattern ensures that a certain system aspect can vary over time, for example the operations that can be applied to an object or the algorithm of a method. The patterns are described by constructs such as the inheritance and reference relations, attempting to emulate more dynamic relationships. As a result, the design patterns demonstrate how awkward it is to program natural concepts of evolution when using a traditional object oriented language. We present a new relation between classes: the context relation. It directly models dynamic evolution, and it is meaningful at both the design and implementation level. At the design level we extend the Unified Modeling Language (UML) to include the context relation as a new form of arrow between classes. At the implementation level we present a small extension of Java. The context relation introduces a new form of dynamic binding that serves as a replacement to delegation. We demonstrate how the context relation can be used to easily model and program numerous design patterns.

No abstract available.

No abstract available.

A seamless approach to the incremental design and reuse of object oriented methods and query specifications is presented. We argue for avoiding or minimizing the effort required for manually reprogramming methods and queries due to schema modifications, and demonstrate how the role of polymorphic reuse mechanisms is exploited for enhancing the adaptiveness of database programs against schema evolution in an object oriented database. The salient features of our approach are the use of propagation patterns and a mechanism for propagation pattern refinement. Propagation patterns are employed as an interesting specification formalism for modeling operational requirements. They encourage the reuse of operational specifications against the structural modification of an object oriented schema. Propagation pattern refinement is suited for the specification of reusable operational modules. It promotes the reusability of propagation patterns toward the operational requirement changes. This approach has a formal basis and emphasizes structural derivation of specifications. The main innovations are in raising the level of abstraction for behavioral schema design, and for making possible the derivation of operational semantics from structural specifications. As a result, both the modularity and reusability of object oriented schemas are increased.

A collection of design patterns was described by Gamma, Helm, Johnson, and Vlissides in 1994. Recognizing that designs change, each pattern ensures that a certain system aspect can vary over time such as the operations that can be applied to an object or the algorithm of a method. The patterns are described by constructs such as the inheritance and reference relations, attempting to emulate more dynamic relationships. As a result, the design patterns demonstrate how awkward it is to program natural concepts of behavioral evolution when using a traditional object-oriented language.In this paper we present a new relation between classes: the context relation. It directly supports behavioral evolution, and it is meaningful at the analysis, design, and implementation level. At the design level we picture a context relation as a new form of arrow between classes. At the implementation level we use a small extension of C++. The basic idea is that if class C is context-related to a base class B, then B-objects can get their functionality dynamically altered by C-objects. Our language construct for doing this is a generalization of the method update in Abadi and Cardelli's imperative object calculus. A C-object may be explicitly attached to a B-object, or it may be implicitly attached to a group of B-objects for the duration of a method invocation. We demonstrate how the context relation can be used to easily model and program the Adapter, Bridge, Chain of Responsibility, Decorator, Iterator, Observer, State, Strategy, and Visitor patterns.

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.

A polymorphic approach to the incremental design and reuse of object-oriented methods and query specifications is presented. Using this approach, the effort required for manually reprogramming methods and queries due to schema modifications can be avoided or minimized. The salient features of of our approach are the use of propagation patterns and a mechanism for propagation pattern refinement. Propagation patterns can be employed as an interesting specification formalism for modeling operational requirements in object-oriented database systems. They encourage the reuse of operational specifications against the structural modification of an object-oriented schema. Propagation pattern refinement is suited for the specification of reusable operational modules, and for achieving reusability of propagation patterns towards the operational requirement changes.>

Abstract 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 System TM C++, a CASE tool for object-oriented design and programming.

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.>

The authors review propagation patterns for describing object-oriented software at a higher level of abstraction than one used by today's 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.>

Tools for preventive maintenance of software which is written following the object-oriented paradigm are discussed. A set of guidelines, called the Law of Demeter is described, and its implications for software maintenance are discussed (K.J. Lieberherr, I. Holland, 1989). The advantages of grammar-based object-oriented design and programming for software maintenance are discussed. Two kinds of grammar-based maintenance tool are studied: class evolution tools, especially an automatic class parameterization tool and growth plan tools with applications to software maintenance planning and regression testing.>

We provide a formal agenda for teaching the object-oriented paradigm in a programming language independent manner, and a tool which supports our teaching approach. Our proposal for a comprehensive study of the subject includes an ordered set of objectives designed to guide the uninitiated user from zero knowledge about object-oriented programming through class definitions, inheritance, subtyping, and the parameterization of classes. This set of graded objectives provides both a useful metric for gauging a student's progress, and a facility through which users can begin their studies at a level commensurate with their experience.

We introduce a simple, programming language independent rule (known in-house as the Law of Demeter™) which encodes the ideas of encapsulation and modularity in an easy to follow form for the object-oriented programmer. You tend to get the following related benefits when you follow the Law of Demeter while minimizing simultaneously code duplication, the number of method arguments and the number of methods per class: Easier software maintenance, less coupling between your methods, better information hiding, narrower interfaces, methods which are easier to reuse, and easier correctness proofs using structural induction. We discuss two important interpretations of the Law (strong and weak) and we prove that any object-oriented program can be transformed to satisfy the Law. We express the Law in several languages which support object-oriented programming, including Flavors, Smalltalk-80, CLOS, C++ and Eiffel.

A conjunctive-normal-form expression (cnf) IS said to be 2-satisfiable if and only if any two of its clauses are simultaneously satisfiable It is shown that every 2-satisfiable cnf has a truth assignment that satisfies at least the fraction h of its clauses, where h = (x/5 -1)/2 ~ 0.618 (the reciprocal of the "golden ratio").The proof ~s constructive m that it provides a polynomtal-ume algorithm that will find for any 2-sausfiable cnf a truth assignment satisfying at least the fraction h of its clauses.Furthermore, this result is optimal m that the constant h IS as large as possible.It is shown that, for any rational h' > h, the set of all 2-satisfiable cnfs that have truth assignments satisfying at least the fraction h' of their clauses ~s an NP-complete set gEY WORDS AND PHRASES doubly transltwe permutations, golden mean, NP-complete, polynomial enumeration algorithm, polynomially constructive reductions, satlsfiabdlty CR CATEGORIES 5.21, 5.25, 5.39

A conjunctive normal form (cnf) is 2-satisfiable, iff any 2 of its clauses are satisfiable. It is shown that every 2-satisfiable cnf s has an interpretation which satisfies at least h·length(s) clauses (h=(√5-1)/2∼0.618). This result is optimal, insofar as the given constant h is maximal. The proof is polynomially constructive, i.e., it yields a polynomial algorithm, which computes an interpretation satisfying h·length(s) clauses for the 2-satisfiable cnf's s. Moreover, if h