This paper presents an equational formulation of an object-oriented data model. In this model, a database is represented as a system of equations over a set of oid's, and a database query is an operation to compute a new system of equations from a given system of equations. During the query processing, our model maintains an equivalence relation on oid's that relates oid's corresponding to the same "real-world entity." By this mechanism, the model achieves a declarative set-based query language and views for objects with identity. Moreover, the query primitives are designed so that queries including object traversal can be evaluated in data-parallel fashion.
This report describes an experiment carried out at ParcPlace-Digitalk which sought to increase the look-and-feel compliance of portable applications built using the company's Smalltalk-based VisualWorks product. We outline the structure of the current VisualWorks user interface framework, and the precise requirements which the experimental system sought to fulfill. We go on to show how we were able to reuse design patterns from the literature in a generative fashion, to direct the evolution of the new framework. This contrasts with most pattern-related work to date, which has concentrated on discerning design patterns in existing systems. Finally, we draw generalizations from our experience concerning the evolution of software architecture using patterns.
Many parallel and distributed programming models are based on some form of shared objects, which may be represented in various ways (e.g., single-copy, replicated, and partitioned (objects). Also, many different operation execution strategies have been designed for each representation. In programming systems that use multiple representations integrated in a single object model, one way to provide multiple execution strategies is to implement each strategy independently from the others. However, this leads to rigid systems and provides little opportunity for code reuse. Instead, we propose a flexible operation execution model that allows the implementation of many different strategies, which can even be changed at runtime. We present the model and a distributed implementation of it. Also, we describe how various execution strategies can be expressed using the model, and we look at applications that benefit from the flexibility offered by it.
http://www.cs.vu.nl/vakgroepen/cs/orca_papers.html
In this paper, the authors share their experiences gathered during the design and implementation of the CORBA Persistent Object Service. There are two problems related to a design and implementation of the Persistence Service: first, OMG leaves the functionality core of the Persistence Service intentionally unspecified; second, OMG encourages reuse of other Object Services without being specific enough in this respect. The paper identifies the key design issues implied both by the intentional lack of OMG specification and the limits of the implementation environment characteristics. At the same time, the paper discusses the benefits and drawbacks of reusing other Object Services, particularly the Relationship and Externalization Services, to support the Persistence Service. Surprisingly, the key lesson learned is that a direct reuse of these Object Services is impossible.
It has been difficult to objectively assess the real value or maturity of the Object Management Group's Object Management Architecture (OMA). While experience reports have appeared in the literature, these have focused more on the functionality of the end-system than on (a) systematically exploring the strengths and weaknesses of the OMA, and (b) providing practical guidelines on the effective use of the OMA for specific software-engineering problems. In this paper we describe a case study in the use of the OMA to integrate legacy software components into a distributed object system. We assess the OMA in this problem context, and indicate strengths and weaknesses of the specification and current implementations. We extrapolate our experience to a broader class of component-based software systems, and recommend an architectural strategy for the effective use of the OMA to this class of systems.
This paper describes how the cmcc compiler reuses code - both internally (reuse between different modules) and externally (reuse between versions for different target machines). The key to reuse are the application frameworks developed for global data-flow analysis, code generation, and instruction scheduling.
The code produced by cmcc is as good as the code produced by the native compilers for the MIPS and SPARC, although significantly less resources have been spent on cmcc (overall, about 6 man years by 2.5 persons), cmcc is implemented in C++, which allowed for a compact expression of the frameworks as class hierarchies. The results support the claim that suitable frameworks facilitate reuse and thereby significantly improve developer effectiveness.
Object-oriented languages with multiple inheritance and automatic conflict resolution typically use a linearization of superclasses to determine which version of a property to inherit when several superclasses provide definitions. Recent work has defined several desirable characteristics for linearizations, the most important being monotonicity, which prohibits inherited properties from skipping over direct superclasses. Combined with DylanUs sealing mechanism, a monotonic linearization enables some compile-time method selection that would otherwise be impossible in the absence of a closed-world assumption.
The Dylan linearization is monotonic, easily described, strictly observes local precedence order, and produces the same ordering as CLOS when that is monotonic. We present an implementation based on merging and a survey of class heterarchies from several large programs, analyzing where commonly used linearizations differ.
Previously, techniques such as class hierarchy analysis and profile-guided receiver class prediction have been demonstrated to greatly improve the performance of applications written in pure object-oriented languages, but the degree to which these results are transferable to applications written in hybrid languages is still unclear. We have developed the Vortex compiler infrastructure, a language-independent optimizing compiler for object-oriented languages, with front-ends for Cecil, C++, and Modula-3, that incorporates these optimizations. In this paper, we describe the Vortex compiler technology and present the results of the first controlled study of these techniques across a range of pure and hybrid object-oriented languages, for medium-sized applications. As an integral part of this study, we define a set of metrics that characterize aspects of the underlying structure of an application and use them to more precisely characterize the studied programs.
BOS is a prototype-based, object-oriented toolkit aimed at better supporting evolutionary software development. BOS attempts to support a spectrum of activities in one environment--ranging from rapid prototyping to code hardening. Features enabling rapid prototyping include a prototype-based object model, an interpreted language, run-time argument constraints, position and keyword arguments, and a user interface toolkit. BOS also provides features for code hardening such as multi-methods, multiple inheritance, external code wrapping mechanisms, and interfaces to other packages such as database management systems. BOS thus enables the end-to-end programming of software in an integrated and unified environment. BOS has been used to develop several full-size applications which have been evaluated and delivered externally.
This paper's primary aim is to improve the understanding of the delegation mechanism. We propose a new characterization of delegation based on the notions of name sharing, property sharing and value sharing. It allows us (1) to clearly differentiate delegation from class-inheritance in particular and more generally from other inheritance mechanisms and (2) to explain how a founded use of delegation relies on a correct semantics of variable property sharing between objects connected by a delegation link. We then describe a model of split objects which is proposed as an example of a disciplined and semantically founded use of delegation, where property sharing expresses viewpoints within objects.
Object-based (i.e. classless) models are very effective for elucidating requirements from users, and they support exploratory programming and rapid prototyping, providing a direct manipulation approach. On the other hand, class-based models have powerful mechanisms to control redundancy, exploit sharing, express extension, and propagate changes to instances.
The price object-based approaches pay is loss of control over change propagation, and potential redundancy. Two mechanisms to overcome this are sharing among objects and definition of objects as extension of others. We examine these mechanisms, and consider the effect that interacting policies for objects sharing and definition-by-extension have on change propagation and replication control. Some implication are that, in absence of meta-objects or extra-language support, monolithic shared parts cannot coexist with prototypes represented as split objects.
This paper describes an algorithm for slicing class hierarchies in C++ programs. Given a program and a set of slicing critieria - program points of particular interest - the algorithm determines those data members, member functions, classes, and inheritance relations that are needed when the criteria are executed. Other components of the class hierarchy may be safely omitted. As with previous work on slicing for non-declarative, or executable, parts of programs, our work can assist in debugging and program understanding. However, unlike previous work, it can also be used to eliminate unneeded components from classes, thereby decreasing the space requirements of the resulting code.
The paper presents several software-engineering problems that are usually not solved by most object-oriented programming languages. It is shown how Description Logics can be used to overcome these problems. The paper motivates the facilities provided by Description Logics in an object-oriented programming scenario. In order to use Description Logics in practical applications, a seamless integration with object-oriented system development methodologies must be realized. The paper presents a unification approach that allows both views to be conveniently used for different subproblems in a modern software-engineering environment.
Nature vs. Nurture? The debate has obsessed the minds of psychologists and philosophers for many years. However, for the object-orienteer, it has never been a problem: an object inherits all of its properties. In this work we ask if an object should not be subject to environment effects and acquire attributes and features from its near and distant neightbors. We answer this question in the affirmative by demonstrating many cases in which the character of an object must be affected by the environment it is put in.
We present a new abstraction mechanism--Environmental Acquisition--which allows a component to inherit properties from its enclosing composite(s). The need for environmental acquisiton is demonstrated in several application domains. We propose a strongly typed model for environmental acquisition that allows static type checking of programs exploiting this mechanism, and compare it to several other mechanisms including ordinary inheritance and delegation. We develop the theory of acquisition that includes topics such as the kinds of links along which acquisition may occur, the behaviour of routine and attribute features under acquisition. Much of the challenge is in allowing acquisiton to be used in a type safe manner.
Most programming languages have used declarative descriptions for describing programs Smalltalk has traditionally used an imperative description. In this paper we describe Smalltalk's usage of the imperative model, and identify program maintenance and delivery issues that arise from it. We then present a declarative alternative for describing Smalltalk programs and show how the use of such a model addresses maintenance, delivery, and portability problems encountered by Smalltalk programmers. This model of Smalltalk programs has been used in the implementation of a commercial Smalltalk development environment and is an integral part of the Smalltalk standard which is currently under development by the X3J20 committee.
Most object-oriented programs have imperfectly designed inheritance hierarchies and imperfectly factored methods, and these imperfections tend to increase with maintenance. Hence, even object-oriented programs are more expensive to maintain, harder to understand and larger than necessary. Automatic restructuring of inheritance hierarchies and refactoring of methods can improve the design of inheritance hierarchies, and the factoring of methods. This results in programs being smaller, having better code re-use and being more consistent. This paper describes Guru, a prototype tool for automatic inheritance hierarchy restructuring and method refactoring of Self programs. Results from realistic applications of the tool are presented.
Several algorithms have been proposed to automatically insert a class into an inheritance hierarchy. But actual hierarchies all include overriden and overloaded properties that these algorithms handle either very partially or not at all. Partially handled means handled provided there is a separate given function f able to compare overloaded properties.
In this paper, we describe a new version of our algorithm (named Ares) which handles automatic class insertion more efficiently using such a function f. Although impossible to fully define, this function can be computed for a number of well defined cases of overloading and overriding. We give a classification of such cases and describe the computation process for a well-defined set of nontrivial cases.
The algorithm preserves these important properties:
A critical concern in the reuse of software is the propagation of changes made to reusable artifacts. Without techniques to manage these changes, multiple versions will propagate through different systems and reusers will not be able to benefit from improvements to the original artifact. We propose to codify the management of change in a software system by means of reuse contracts that record the protocol between managers and users of a reusable asset. Just as real world contracts can be extended, amended and customised, reuse contracts are subject to parallel changes encoded by formal reuse operators: extension, refinement and concretisation. Reuse contracts and their operators serve as structured documentation and facilitate the propagation of changes to reusable assets by indicating how much work is necessary to update previously built applications, where and how to test and how to adjust these applications.
To use modern hardware effectively, compilers need extensive control-flow information. Unfortunately, the frequent method invocations in object-oriented languages obscure control flow. In this paper, we describe and evaluate a range of analysis techniques to convert method invocations into direct calls for statically-typed object-oriented languages. We present simple algorithms for type hierarchy analysis, aggregate analysis, and interprocedural and intraprocedural type propagation. These algorithms are also fast, O(|procedures|(2) * n) worst case time (linear in practice) for our slowest analysis, where n is the size of the largest procedure, and are thus practical for use in a compiler. When they fail, we introduce cause analysis to reveal the source of imprecision and suggest where more powerful algorithms may be warranted. We show that our simple analyses perform almost as well as an oracle that revolves all method invocations that invoke only a single procedure.
We study the direct cost of virtual function calls in C++ programs, assuming the standard implementation using virtual function tables. We measure this overhead experimentally for a number of large benchmark programs, using a combination of executable editing and processor simulation. Our results show that the C++ programs measured spend a median of 8% of their time in dispatch code even though this code represents less than 4% of the instructions executed. For "all virtuals" versions of the programs, the median overhead rises to 20% (12% of the instructions). On future processors, these overheads are likely to increase moderately.
Virtual functions make code easier for programmers to reuse but also make it harder to compilers to analyze. We investigate the ability of three static analysis algorithms to improve C++ programs by resolving virtual function calls, reducing program complexity so as to improve both human and automated program understanding and analysis. In measurements of 5 programs of significant size (5000 to 20000 lines of code each) we found that the most precise of the three algorithms resolved 60% of the virtual function calls and reduced compiled code size by 22%. Because of its accuracy and speed (2500 lines per second), this algorithm is an excellent candidate for inclusion in production C++ compilers.
Evolution of software systems is prompted by all sorts of changes. A change case provides the ability to identify and incorporate expected future change into a design to enhance the long-term robustness of that design. This paper demonstrates how the use case, a well known technique in object-oriented analysis, is adapted to identify and articulate anticipated system changes. In this paper, we define change cases and demonstrate how change cases are captured by the analyst. We present examples to illustrate how change cases can influence present system design and point the way toward designs that more easily accommodate expected future changes.
In this paper we present a method of code implementation that works in conjunction with collaboration and responsibility based analysis modeling techniques to achieve better code reuse. Our approach maintains a closer mapping from responsibilities in the analysis model to entities in the implementation. In so doing, it leverages the features of flexible design and design reuse found in collaboration based design models to provide similar adaptability and reuse in the implementation. Our approach requires no special development tools and uses only standard features available in the C++ language. In an earlier paper we described the basic mechanisms used by our approach and discussed its advantages in comparison to the framework approach. In this paper we show how our approach combines code and design reuse and describe specific techniques that can be used in the development of larger applications.
Software products are often built on system platforms that support specific characteristics of the product. These characteristics are either captured informally in design guideline documents or in specialized design and implementation languages.
Our approach is to describe and name the constraints separately in a design constraint language called CDL, which is based on an extraordinarily concise logic of parse trees. Designs are then annotated with the names of the constraints they are supposed to satisfy.
We discuss how the design constraint language is integrated into a design language environment. We exhibit industrial and experimental evidence that our choice of design constraint language allows us to formalize naturally and succinctly common design characteristics.
Tracing the changing dynamics of object-oriented frameworks, design patterns, architectural styles, and subsystems during the development and reuse cycle can aid producing complex systems. Unfortunately, current object-oriented programming tools are relatively oblivious to the rich architectural abstractions in a system.
This paper shows that architecture-oriented visualization, the presentation of system dynamics in terms of its architectural abstractions, is highly beneficial in designing complex systems. In addition, the paper presents architecture-aware instrumentation, a new technique for building efficient on-line instrumentation to support architectural queries. We demonstrate the effectiveness and performance of the scheme with case studies in the design of the Choices object-oriented operations system.
Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems. The result is a system that automatically generates the run-time system, along with a specification of the basic operations on the primitive data types. The same approach should produce visual programming languages for other problem domains.
We present a graphical environment for parallel object-oriented programming. It provides visual tools to develop and debug object-oriented programs as well as concurrent systems. This environment was derived from a structural operational semantics of an extension of the Eiffel language, Eiffel//. Object-related features of the language (inheritance, polymorphism) are formalized using a big-step semantics, while the interleaving model of concurrency is expressed with small-step semantics. Without user instrumentation, the interactive environment proposes features such as step-by-step animated executions, graphical visualization of object and process topology, futures and pending requests, control of interleaving, deadlock detection.