Boris Magnusson

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.

A model for semi-(a)synchronous collaborative editing

This paper presents a new model for semi-synchronous collaborative editing. It fills the gap between asynchronous and synchronous editing styles. The model is based on hierarchically partitioned documents, fine-grained version control, and a mechanism called active diffs for supplying collaboration awareness. The aim of the model is to provide an editing style that better suits the way people actually are working when editing a document or program together, using different writing strategies during different activities.

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.

Ad-hoc composition of pervasive services in the PalCom architecture

We present an architecture supporting ad-hoc composition of pervasive services, an open-source framework that implements it, and the key design principles behind it. The architecture focuses on direct human interaction, supporting combination of devices and services that are not explicitly designed to work together. The focus is on local networks, but extension is possible to wide area networks, interconnecting several local networks. The information about how services are connected and coordinated is collected in a new construct called assemblies. Separating this information from the services themselves allows combination of existing services in new creative ways without changing them. Assemblies can provide new services and in this way be organized hierarchically. The assembly makes the architecture of a pervasive system explicit, providing an overview understandable to users. Discovery and connections across different network technologies is supported. The architecture has been used for applications in large scale networks, and offers mechanisms useful for system integration in general.

The role of language paradigms in teaching programming

The purpose of this panel is to confront the wide variety of opinions on the role of language paradigms in teaching programming. We have selected four divergent opinions:Armstrong says that concurrent programming is considered difficult because it is taught in the wrong paradigm, namely imperative or object-oriented programming. Instead, concurrency should be taught using a paradigm that makes it simple.Flatt says that everyone should be taught how to program, not just computer science majors. Further, programming should be taught as an extension of what students already know, which is algebra. More important than a particular paradigm, however, is teaching students a design process.Magnusson says that object-oriented programming must be the first and principal paradigm, because it is best for teaching how to analyze problems and structure solutions. Other paradigms can be taught after students have a solid understanding of OO.Van Roy says that programming should be taught in terms of concepts, not paradigms. Common paradigms (functional, OO, etc.) then appear naturally, depending on the concepts used..The panel will confront these opinions to enrich our understanding of how to teach programming.

Teaching extreme programming to large groups of students

We find the extreme programming methodology highly suitable for introducing undergraduate students to software engineering. To be able to apply this methodology at a reasonable teaching cost for large student groups, we have developed two courses that work in tandem: a team programming course taken by more than 100 students, and a coaching course taken by around 25 students. In this paper we describe our view of how extreme programming fits into the software engineering curriculum, our approach to teaching it, and our experiences, based on two years of running these courses. Particularly important aspects of our set up include team coaching (by older students), fixed working hours, and colocation during development. Our experiences so far are very positive, and we see that students get a good basic understanding of the important concepts in software engineering, rooted in their own practical experience.

The Mjølner Environment: Direct Interaction with Abstractions

This paper presents the user interface to programs and their execution in the Mjolner Programming Environment. The key idea is to present the programming language abstractions, such as classes and procedures, as individual windows which the user can interact with directly. This approach is used consistently to visualize both a program and its execution. The windows are arranged hierarchically reflecting the static nesting of blocks. The window hierarchy gives powerful support for interaction and navigation in a program. Incremental compilation techniques are used to make a high level of interaction and integration possible.

Pervasive applications through scripted assemblies of services

This paper proposes a technique for letting end users build pervasive applications by combining services on networked devices. The approach avoids relying on standardized service interfaces which are deemed too limiting, and instead makes use of migratable user interfaces and scripted combinations of services.

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.