RELENG 2013 – Proceedings

Foreword
We are pleased to present the proceedings of the 1st International Workshop on Release Engineering (RELENG 2013), which was held in San Francisco on Monday the 20th of May 2013, co-located with ICSE 2013. With an actual release engineer as one of the co-organizers, 40% of the PC consisting of actual release engineers, and a separate abstract track for practitioner reports (in addition to a regular academic track), RELENG has been built from the ground up to bring together researchers and practitioners in the area of release engineering to meet each other and share experiences, tools and techniques to help organizations release high quality software products on time.

Adding Automatic Dependency Processing to Makefile-Based Build Systems with Amake
Jim Buffenbarger
(Boise State University, USA)
This paper explains how to improve the quality of an existing Makefile-based build system, using a new variant of Make. Ordinary file-oriented dependencies are detected, recorded, and monitored automatically. Checksums are compared, rather than timestamps. Other important dependencies are also processed automatically. This provides an accurate, compact, and low-maintenance build system. Experiences with the Linux kernel/driver build system are described.

Eliciting Operations Requirements for Applications
Len Bass, Ross Jeffery, Hiroshi Wada, Ingo Weber, and Liming Zhu
(NICTA, Australia; UNSW, Australia)
The DevOps community advocates communication between the operations staff and the development staff as a means of ensuring that the developers understand the issues associated with operations. This paper argues that communication is too vague and that there are a variety of specific and well known sources that developers can examine to determine requirements to support the installation and operations of an application product. These sources include standards, process descriptions, studies about sources of failure in configuration and upgrade, and models that include both product and process.

Kanbanize the Release Engineering Process
Noureddine Kerzazi and Pierre N. Robillard
(Payza, Canada; Polytechnique Montréal, Canada)
Release management process must be adapted when IT organizations scale up to avoid discontinuity at the release flow and to preserve the software quality. This paper reports on means to improve the release process in a large-scale project. It discusses the rationale behind adopting Kanban principles for release management, how to implement these principles within a transitional approach, and what are the benefits. The paper discusses the post-transitional product to assess the status of the outcomes.

Ant Build Maintenance with Formiga
Ryan Hardt and Ethan V. Munson
(University of Wisconsin-Milwaukee, USA)
"Build maintenance" refers to the changes made to the build system as a software project evolves over time and has been shown to impose a significant overhead on overall development costs, in part because changes to source code often require parallel changes in the build system. However, little tool support exists to assist developers with build maintenance, particularly for those changes that must accompany changes to the source code. Formiga is a build maintenance and dependency discovery tool for the Ant build system. Formiga’s primary uses are to automate build changes as the source code is updated, to assist in build refactoring, to identify the build dependencies within a software project, and to clarify the dependency differences between different versions of build files. Formiga is implemented as an IDE plugin, which allows it to recognize when project resources are updated and automatically update the build system accordingly. This implementation also allows it to leverage existing metaphors used by developers to maintain source code, thus making it easier to use.

Charon: Declarative Provisioning and Deployment
Eelco Dolstra, Rob Vermaas, and Shea Levy
(LogicBlox, USA)
We introduce Charon, a tool for automated provisioning and deployment of networks of machines from declarative specifications. Building upon NixOS, a Linux distribution with a purely functional configuration management model, Charon specifications completely describe the desired configuration of sets of ``logical'' machines, including all software packages and services that need to be present on those machines, as well as their desired ``physical'' characteristics. Given such specifications, Charon will provision cloud resources (such as Amazon EC2 instances) as required, build and deploy packages, and activate services. We argue why declarativity and integrated provisioning and configuration management are important properties, and describe our experience with Charon.

Releasing Sooner or Later: An Optimization Approach and Its Case Study Evaluation
Jason Ho and Guenther Ruhe
(University of Calgary, Canada; Expert Decisions, Canada)
Decisions about the release date need to balance between the degree of readiness (quality) of the product and the potential competitive advantage and added value of (early) delivery. Based on an existing optimization approach for solving the maximum value release planning problem for a fixed release time, we provide a re-optimization approach for which includes local and global re-planning exchange operations to determine the outcome of varying the release dates. The proposed method determines a set of trade-off solutions related to (i) the value of the features implemented, (ii) their estimated quality, and (iii) the release time. The approach is evaluated by a real-world case study taken from an ongoing project which is to develop the new main release 2.0 for the release planning decision support platform ReleasePlanner v1.6.

Branching Strategies Based on Social Networks
Noureddine Kerzazi
(Payza, Canada)
Effective code branching strategy must be adapted to the unique needs of each organization. Teams and workflows organization as well as software architecture should be reflected in the branching strategies to maximize productivity and to minimize development risks. When conceptualized carefully, proper branching structure produces superior results. This paper proposes an analytic approach for adapting structure of branches based on Social Network Analysis to find out Branch-dependencies. The article provides context-based scenarios of successful application of such branching strategies in different situations.

What Effect does Distributed Version Control have on OSS Project Organization?
Peter C. Rigby, Earl T. Barr, Christian Bird, Premkumar Devanbu, and Daniel M. German
(Concordia University, Canada; University College London, UK; Microsoft Research, USA; UC Davis, USA; University of Victoria, Canada)
Many Open Source Software (OSS) projects are moving form Centralized Version Control (CVC) to Distributed Version Control (DVC). The effect of this shift on project organization and developer collaboration is not well understood. In this paper, we use a theoretical argument to evaluate the appropriateness of using DVC in the context of two very common organization forms in OSS: a dictatorship and a peer group. We find that DVC facilitates large hierarchical communities as well as smaller groups of developers, while CVC allows for consensus-building by a peer group. We also find that the flexibility of DVC systems allows for diverse styles of developer collaboration. With CVC, changes flow up and down (and publicly) via a central repository. In contrast, DVC facilitates collaboration in which work output can flow sideways (and privately) between collaborators, with no repository being inherently more important or central. These sideways flows are a relatively new concept. Developers on the Linux project, who tend to be experienced DVC users, cluster around "sandboxes:" repositories where developers can work together on a particular topic, isolating their changes from other developers. In this work, we focus on two large, mature OSS projects to illustrate these findings. However, we suggest that social media sites like GitHub may engender other original styles of collaboration that deserve further study.

The Future of Continuous Integration in GNOME
Colin Walters, Germán Poo-Caamaño, and Daniel M. German
(Red Hat, USA; University of Victoria, Canada)
In Free and Open Source Software (FOSS) projects based on Linux systems, the users usually install the software from distributions. The distributions act as intermediaries between software developers and users. Distributors collect the source code of the different projects and package them, ready to be installed by the users. Packages seems to work well for managing and distributing stable major and minor releases. It presents, however, various release management challenges for developers of projects with multiples dependencies not always available in the stable version of their systems. In projects like GNOME, composed of dozens of individual components, developers must build newer versions of the libraries and applications that their applications depend upon before working in their own projects. This process can be cumbersome for developers who are not programmers, such as user interaction designers or technical writers. In this paper we describe some of the problems that the current distribution model presents to do continuous integration, testing and deployment for developers in GNOME, and present ongoing work intended to address these problems that uses a git-like approach to the building and deployment of applications.

RELENG 2013 – Proceedings

1st International Workshop on Release Engineering (RELENG)