Timeline Variability: The Variability of Binding Time of Variation Points
E. Dolstra, Gert Florijn, Eelco Visser · 2003
Timeline variability is the ability of a software system to have variation points bound at different moments of the system’s life-cycle. Virtually every non-trivial software system exhibits variability: the property that the set of features— characteristics of the system that are relevant to some stakeholder— can be changed at certain points in the system’s life-cycle. The parts of the system that implement the ability to make such changes are called variation points. Selecting some variant supported by a variation point is called binding the variant. Every variation point has at least one associated binding time: the moment in the system’s life-cycle at which the variation point can be bound. A more detailed exposition of this terminology can be found in, e.g., [7, 2]. For example, the decision to build an operating system kernel with multiprocessor support, or to build a “light” or “professional” version of a word processor, might be implemented at build time. On the other hand, the decision to include support for some brand of hard drive in an operating system, or to use some particular language for spell checking in a word processor, might be made at runtime. Generally, one would like variation points to be as flexible as possible with regard to binding time. That is, ideally one wants to have the ability to bind a variation point at build time, installation time, runtime, and so on. This leads to the notion of timeline variability: that certain features can be bound at several stages of the life-cycle. We do not formalise the term timeline here. Intuitively, we use if to refer to the set of distinguished moments during the build and deployment process where a user can potentially select variants. For example, the Linux operating system kernel allows functionality, e.g., device drivers, to be included either at build time or at runtime. However, changing features at runtime proceeds through entirely different interfaces than changing them at build time. Similarly, the Apache httpd webserver allows server extensions to be included at build time or at load time, but through different configuration mechanisms. Microsoft Office 2000 allows components to be installed either at install time proper or on demand, at runtime. The concept of timeline variability—that is, variability of binding time—should not be confused with the binding time of variation points. In this paper we illustrate timeline variability through two case studies, Apache and the Linux kernel, and show that the two main technical issues in timeline variability are inconsistent configuration interfaces and ad hoc implementation mechanisms. We also provide some directions for future research.