In several works on design methodologies, design patterns, programming language design and application frameworks, the need for adequate higher-level 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. 1 Introduction The step from proc...

AbstractÐSoftware merging is an essential aspect of the maintenance and evolution of large-scale software systems. This paper provides a comprehensive survey and analysis of available merge approaches. Over the years, a wide variety of different merge techniques has been proposed. While initial techniques were purely based on textual merging, more powerful approaches also take the syntax and semantics of the software into account. There is a tendency towards operation-based merging because of its increased expressiveness. Another tendency is to try to define merge techniques that are as general, accurate, scalable, and customizable as possible, so that they can be used in any phase in the software life-cycle and detect as many conflicts as possible. After comparing the possible merge techniques, we suggest a number of important open problems and future research directions. Index TermsÐSoftware merging, large-scale software development, merge conflicts, conflict detection, conflict resolution. æ 1

Disciplined support for evolution of software artifacts is important in all phases of the software life-cycle. In order to achieve this support, a uniform underlying foundation for software evolution is necessary. While, in the past, reuse contracts have been proposed as such a formalism in a number of different domains, this paper generalises the formalism, and integrates it into the UML metamodel. As such, support for evolution becomes readily available for many kinds of UML models, ranging from requirements to the implementation phase.

We apply formal concept analysis to the understanding, analysis, and code inspection of individual JAVA classes. A concept is a maximal set of methods and fields such that each field is used by every method and each method uses every field. A real life case study shows that the mathematical lattice of concepts is a valuable means in studying the interface of a large class, understanding and discovering errors in its structure, and in performing an effective inspection of its code.

Dynamic linking provides a way to share code components across applications and across the network. But managing these relationships as new code versions are developed gives rise to a range of problems well recognized by system support personnel. Operating system and language designers attempt to design solutions to these problems into the latest versions of their products. In this paper we report on some troublesome features that crop up in the runtime systems of object-oriented languages designed for distributed code-sharing.

Framework evolution may break existing users, which need to be migrated to the new framework version. This is a tedious and error-prone process that benefits from automation. Existing approaches compare two versions of the framework code in order to find changes caused by refactorings. However, other kinds of changes exist, which are relevant for the migration. In this paper, we propose to mine framework usage change rules from already ported instantiations, the latter being applications build on top of the framework, or test cases maintained by the framework developers. Our evaluation shows that our approach finds usage changes not only caused by refactorings, but also by conceptual changes within the framework. Further, it copes well with some issues that plague tools focusing on finding refactorings such as deprecated program elements or multiple changes applied to a single program element.

Abstract not found