Ulf Asklund

Fine-grained revision control for collaborative software development

This paper presents a framework for controlling the evolution of complex software systems concurrently developed by teams of software engineers. A general technique for fine-grained revision control of hierarchically structured information, such as programs and documents, is described and evaluated. All levels in the hierarchy are revision controlled, leaves as well as branch nodes. The technique supports sharing of unchanged nodes among revisions, automatic change propagation, and change-oriented representation of differences. Its use in a software development environment is presented, facilitating optimistic check-out of revisions and alternatives, check-in with incremental merge support, visualization of change propagation, and an integrated flexible diff-ing technique providing group awareness for team members.

Fine Grained Version Control of Configurations in COOP/Orm

This paper describes a unified approach to version control of documents and configurations. Hierarchical structure, which is present in most documents such as programs, is recognized and utilized in a fine-grained version control system. The same mechanism is used for version control of configurations and extended to handle DAGs as well as trees. Change propagation within one hierarchical document is automatic while bindings between documents are explicit. The model is novel because of its integration of version and configuration control, fine-grained version control, and explicit graphical user interface. It supports teams of distributed users by offering optimistic check-out with strong support for merging of alternatives.

The Unified Extensional Versioning Model

Versioning of components in a system is a well-researched field where various adequate techniques have already been established. In this paper, we look at how versioning can be extended to cover also the structural aspects of a system. There exist two basic techniques for versioning - intentional and extensional - and we propose a unified extensional versioning model for versioning of both components and structure in the same way. The unified model is described in detail and three different policies that can be implemented on top of the general model are exemplified/illustrated by three prototype tools constructed by the authors. The model is analysed with respect to the number of versions and configurations it generates and has to manage. Finally, the unified extensional model is compared to more traditional intentional models on some important parameters. The conclusions are that the unified model is indeed viable. It not only provides the functionality offered by the intentional model with respect to flexibility during development and management of combinatoric complexity, but also offers a framework for management of configurations that enables systems to provide much more advanced support than is commonly available.

A study of configuration management in open source software projects

Projects where developers are geographically distributed and with high personnel turnover are usually considered to be hard to manage. Any organisation that successfully handles such projects merits closer analysis so that lessons can be learned and good practice disseminated. Open source software projects represent such a case. One important factor is good configuration management practices. In this paper, the authors examine the configuration management process for some open source software projects and analyse how process, tool support, and people aspects of configuration management contribute to this success. Finally, we discuss best practices and how lessons learned from open source software can be transferred to more traditional ways of developing software.

Refactoring-aware versioning in Eclipse

To fully support refactorings in a team development environment we have implemented a refactoring-aware repository provider as an extension plug-in to the Java Development Tools in Eclipse. The versioning system treats refactorings as first-class changes described as semantic ac- tions rather than the set of resulting changes scattered over the source tree. We also introduce refactoring-aware merge, which merges refactorings as well as traditional changes utilizing the se- mantics of the refactorings to detect and resolve merge conflicts. It also ensures that the semantic meaning of a refactoring is preserved after the merge.

A Case-Study of Configuration Management with ClearCase in an Industrial Environment

This paper reports from a case study where the configuration management system ClearCase is used in a large scale industrial application. The focus of the study is on the functionality offered and how it matches the needs in this particular situation. The paper reports on situations where ClearCase has turned out to be cumbersome to use or is lacking functionality. Improvements are outlined for how the problems can be solved or the situations better supported. The suggested improvements are influenced by experience with the COOP/Orm research prototype and some of the improvements are illustrated with functionality available in this integrated environment.

A software configuration management course

Software Configuration Management has been a big success in research and creation of tools. There are also many vendors in the market of selling courses to companies. However, in the education sector Software Configuration Management has still not quite made it at least not into the university curriculum. It is either not taught at all or is just a minor part of a general course in software engineering. In this paper, we report on our experience with giving a full course entirely dedicated to Software Configuration Management topics and start a discussion of what ideally should be the goal and contents of such a course.

Experiences: Distributed Development and Software Configuration Management

Distributed development occurs more frequently today than only some years ago. Distributed development states new demands on Configuration Management and used processes. This paper describes experiences from more than ten different Swedish companies in the area of distributed development and software configuration management. We present definitions, experiences and hints on Software Configuration Management from three different aspects; four cases of distributed development, architecture, and working methods in some key-areas.

Quality improvements by integrating development processes

Software is an increasing and important part of many products and systems. Software, hardware, and system level components have been developed and produced following separate processes. However, in order to improve the quality of the final complex product, requirements and prospects for an automatic integrated process support are called for. Product data management (PDM) has focused on hardware products, while software configuration management (SCM) has aimed to support software development. Several attempts to integrate tools from these domains exist, but they all show small visible success. The reason for this is that integration goes far beyond tool issues only. According to our experiences, three main factors play a crucial role for a successful integration: tools and technologies, processes, and people. This paper analyses the main characteristics of PDM and SCM, describes the three integration factors, identifies a model for the integration process, and pin-points the main challenges to achieve a successful integration of hardware and software development. The complexity of the problems is shown through several case studies.

Experiences from Monitoring Effects of Architectural Changes

A common situation is that an initial architecture has been sufficient in the initial phases of a project, but when the size and complexity of the product increases the architecture must be changed. In this paper experiences are presented from changing an architecture into independent units, providing basic reuse of main functionality although giving higher priority to independence than reuse. An objective was also to introduce metrics in order to monitor the architectural changes. The change was studied in a case-study through weekly meetings with the team, collected metrics, and questionnaires. The new architecture was well received by the development team, who found it to be less fragile. Concerning the metrics for monitoring it was concluded that a high abstraction level was useful for the purpose.