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. The rule achieves the following related benefits if code duplication, the number of method arguments and the number of methods per class are minimized: Easier software maintenance, less coupling between your methods, better information hiding, methods which are easier to reuse, and easier correctness proofs using structural induction. We show relationships between the Law and software engineering techniques, such as coupling control, information hiding, information restriction, localization of information, narrow interfaces and 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 p...

We give an axiomatic definition of the basic structure, called a class dictionary graph, used by object-oriented designers and programmers during the software development process. The contributions of this paper are twofold: An axiomatic foundation for objectoriented data modeling and efficient algorithms for checking whether a given data model satisfies the axioms. The presented data model is the foundation of a number of techniques for developing object-oriented systems including adaptive software, schema abstraction from object examples, schema optimization, planning techniques for system development, the Law of Demeter, etc. Keywords: Object-oriented data modeling and programming, algorithms and tools for objectoriented design, axioms for data models, Demeter Method. 1 Introduction In object-oriented data modeling and programming, each entity of the problem domain is represented by a set of objects with relations and operations. Each object is composed of part objects/su...

. Sound engineering approaches to user interface design require the formalization of key interaction concepts, one of them being metaphor. Work on interface metaphors has, however, been largely non-formal so far. The few existing formal theories of metaphor have been developed in the context of natural language understanding, learning, or reasoning. We propose to formalize interface metaphors by algebraic specifications. This approach provides a comprehensive formalization for the essential aspects of metaphorical user interfaces. Specifically, metaphor domains are being formalized by algebras, metaphorical mappings by morphisms, and image-schemas by categories. The paper explains these concepts and the approach, using examples of spatial and spatializing metaphors. 1. Introduction Metaphor pervades communication. Metaphorical thought, action, and language are not only essential to interpersonal communication [Lakoff and Johnson 1980], but to human-computer communication as well. Sinc...

The contributions of this paper are two-fold: First we introduce a novel, axiomatically defined, object-oriented data model, called the Demeter kernel model, and second we present abstraction and optimization algorithms and their relationships for designing classes from objects in the kernel model. We analyze several computational problems underlying the class design process which is divided into two phases: a learning phase and an optimization phase. This study focuses on approximation algorithms for the optimization phase and leads to a better understanding and a partial automation of the object-oriented design process. The algorithms and the theory presented in this paper have been implemented in the C++ Demeter System TM , a CASE tool for object-oriented design and programming. Keywords: Object-oriented programming and design, reverse engineering, formal software engineering techniques, class hierarchy optimization. Acknowledgements: Preliminary versions of this paper ...

Many approaches to programming emphasize the use of interfaces. The basic idea is to decompose programs into modules and to specify how each module's interface behaves. This makes it easier to reason about programs because one can rely on a module's speci#cation rather than examining its implementation, which is more complicated.

ii Class organizations (schemas) evolve over the life cycle of object-oriented systems for avariety of reasons. This issue has recently been a subject of increasing attention in the literature of both object-oriented languages and object-oriented database systems. One of the most common forms of evolution involves the extension of an existing system by addition of new classes of objects or the addition of attributes to the original objects. Sometimes class structures are reorganized even when the set of objects is unchanged. In this case the reorganization might represent an optimization of the system, or just a change in the users ' perspective. At the other extreme, a class reorganization might re ect not only the extension and reclassi cation of existing objects, but also structural changes (other than addition of attributes) in the original objects. This work provides a mathematical treatment of a calculus of class transformations. Three kinds of transformations that commonly occur in the evolution of class structures are considered: object-extending, object-preserving, and language-preserving. For each kind of transformation, methods for automating the maintenance of systems based on the evolving class structure are discussed. The language-preserving transformations are a special case of transformations that change the structure of existing objects. If an object schema is decorated with concrete syntax, it de nes not only a class structure, but also a language for describing the objects. When two schemas de ne the same language but di erent classes, the language may be used to guide the discovery of analogies between the classes. The resulting analogies may then be used to transport functionality between domains. iii Acknowledgments Iwould like to thank my advisor, Karl Lieberherr, for his generous support, guidance, and feedback. I would also like to thank my wife, Vickie, for her constant encouragement and understanding without which thiswork would not have been possible. iv

. Model checking techniques have been successfully applied to the verification of correctness properties of complex hardware systems and communication protocols. This success has fueled the application of these techniques to software systems. To date, those efforts have been targeted at concurrent software whose complexity lies, primarily, in the large number of possible execution orderings of asynchronously executing program actions. In this paper, we apply existing model checking techniques to parameterizable implementations of container data structures. In contrast to most of the concurrent systems that have been studied in the model checking literature, the complexity of these implementations lies in their data structures and algorithms. We report our experiences model checking specifications of correctness properties of queue, stack and priority queue data structures implemented in Ada. Keywords : Model checking, temporal logic, assume-guarantee reasoning, generic containers 1 Int...

Search on wide area distributed systems is plagued by the high latencies inherent in remote access. A solution is to prefetch information before it is requested by the searcher to hide latency. But this raises the problem of knowing what to prefetch, since fetching data that will not be used can actually hurt performance. This paper proposes extending the Unix file model to support dynamic sets, short-lived and unordered collections of objects created by searchers to hold the results of queries. An object's membership in a set is a hint of future access, informing the system that prefetching that object can improve performance. An additional benefit of using set membership as the hint is that it allows the system to determine the order in which objects are returned to the searcher, further increasing the opportunity for performance improvement. This paper presents the design of SETS, a system extension to Unix to provide dynamic sets. A performance evaluation of SETS shows dynamic sets...

A key goal of distributed systems is to provide prompt access to shared information repositories. The high latency of remote access is a serious impediment to this goal. This paper describes a new file system abstraction called dynamic sets -- unordered collections created by an application to hold the files it intends to process. Applications that iterate on the set to access its members allow the system to reduce the aggregate I/O latency by exploiting the non-determinism and asychrony inherent in the semantics of set iterators. This reduction in latency comes without relying on reference locality, without modifying DFS servers and protocols, and without unduly complicating the programming model. This paper presents this abstraction and describes an implementation of it that runs on local and distributed file systems, as well as the World Wide Web. Dynamic sets demonstrate substantial performance gains -- up to 50% savings in runtime for search on NFS, and up to 90% reduction in I/O latency for Web searches. 1