10th International Software
Product Line Conference
(SPLC 2006)
21-24 August 2006
Baltimore,
Maryland, USA
Conference Tutorials
Tutorial Chair: Daniel J. Paulish, Siemens Corporate Research
Tutorial 1 (T1)
An Introduction to Product Line
Requirements Engineering
Brian Berenbach
21 August 2006, (Half Day -
AM)
Requirements elicitation and management has become ever more important as product lines become more complex and time to market is shortened. Outsourcing has added a new dimension to requirements management, exacerbating problems associated with transitioning from analysis to design. This half day tutorial will provide an introduction to product line requirements engineering from the perspective of project and product management: how it impacts project managers, quality assurance personnel, requirements analysts, developers and testers. Topics covered will include product line requirements, feature modeling, CMMI compliant requirements management and requirements analysis processes (both UML and text based). Business analysts who are interested in using UML for modeling will also find the course interesting. No formal knowledge of programming is required.
Tutorial 2 (T2)
New Methods Behind the New Generation of
Software Product Lines Success Stories
Charles Krueger
21 August
2006, (Half Day - AM)
A new generation of software product line success stories is being driven by a new generation of methods, tools and techniques. While early software product line case studies at the genesis of the field revealed some of the best software engineering improvement metrics seen in four decades, the latest generation of software product line success stories exhibit even greater improvements, extending benefits beyond product creation into maintenance and evolution, lowering the overall complexity of product line development, increasing the scalability of product line portfolios, and enabling organizations to make the transition to software product line practice with orders of magnitude less time, cost and effort. We explore some of the important new methods such as software mass customization sans application engineering, minimally invasive transitions, bounded product line combinatorics, and product line lifecycle management.
Tutorial 3 (T3)
Introduction to Software Product
Lines
Patrick Donohoe
21 August 2006, (Half Day - AM)
Software product lines have emerged as a new software development paradigm of great importance. A software product line is a set of software intensive systems sharing a common, managed set of features, and that are developed in a disciplined fashion using a common set of core assets. Organizations developing a portfolio of products as a software product line are experiencing order-of-magnitude improvements in cost, time to market, staff productivity, and quality of the deployed products.
This tutorial will introduce the essential activities and underlying practice areas of software product line development. It will review the basic concepts of software product lines, discuss the costs and benefits of product line adoption, introduce the SEI's Framework for Software Product Line Practice, and describe approaches to applying the practices of the framework.
Tutorial 4 (T4)
Creating Reusable Test Assets in a
Software Product Line
John McGregor
21 August 2006, (Half Day - PM)
This tutorial focuses on the test assets and test processes created by a software product line organization. The tutorial will allow participants to consider how to modify existing testing practices to take advantage of strategic reuse. The software product line approach blends organizational management, technical management and software engineering principles to efficiently and effectively produce a set of related products. The major test assets: test plans, test cases, test data, and test reports are created at multiple levels of abstraction to facilitate their reuse. A product line organization also defines a test process that differs from the test process in a traditional development organization. This tutorial will allow participants to consider how to modify existing testing practices to take advantage of strategic reuse. At the end of this tutorial you will be able to:
- Understand the basic concepts of testing in software product line organizations.
- Understand the benefits, costs and risks of creating reusable test assets.
- Define a test process for your product line organization.
- Identify the steps necessary to initiate these activities for your organization.
Tutorial 5 (T5)
Leveraging Model Driven Engineering in
Software Product Lines
Bruce Trask, Angel Roman
21 August 2006,
(Half Day - PM)
Model Driven Engineering (MDE) is a new innovation in the software industry that has proven to work synergistically with Software Product Line Architectures. It can provide the tools necessary to fully harness the power of Software Product Lines. The major players in the software industry including commerical companies such as IBM, Microsoft, standards bodies including the Object Management Group, and leading universities such as the ISIS group at Vanderbilt University are fully embracing this MDE/PLA combination. IBM is spearheading the Eclipse Foundation including its MDE tools. Microsoft has launched their Software Factories foray into the MDE space. Software groups such as the ISIS group at Vanderbilt are using these MDE techniques in combination with PLAs for very complex systems. The Object Management Group is working on standardizing the various facets of MDE. The goal of this tutorial is to educate attendees on what MDE technologies are, how exactly they relate synergistically to Product Line Architectures, and how to actually apply them using an existing Eclipse implementation.
Tutorial 6 (T6)
Introduction to Software Product Line
Adoption
Linda Northrop, Larry Jones
21 August 2006, (Half Day - PM)
The tremendous benefits of taking a software product line approach are well documented. Organizations have achieved significant reductions in cost and time to market and, at the same time, increased the quality of families of their software systems. However, to date, there are considerable barriers to organizational adoption of product line practices. Phased adoption is attractive as a risk reduction and fiscally viable proposition. This tutorial describes a phased, pattern-based approach to software product line adoption. A phased adoption strategy is attractive as a risk reduction and fiscally viable proposition. The tutorial begins with a discussion of software product line adoption issues and then presents the Adoption Factory pattern. The Adoption Factory pattern provides a roadmap for phased, product line adoption. The tutorial covers the Adoption Factory in detail, including focus areas, phases, subpatterns, related practice areas, outputs, and roles. Examples of product line adoption plans following the pattern are used to illustrate its utility. The tutorial also describes strategies for creating synergy within an organization between product line adoption and ongoing CMMI or other improvement initiatives.
Tutorial 8 (T8)
Software Product Line Variability
Management
Klaus Pohl, Frank van der Linden, Andreas Metzger
21
August 2006, (All Day)
Tutorial participants will become familiar with the key concepts of software product line engineering and will learn how to apply variability management in practice. The participants will be able to differentiate between the two processes domain engineering and application engineering, and will have an understanding of the differences between single-system development and the development activities in product line engineering. The focus will be on requirements engineering and architectural design activities, and the relationships between them. The participants will further have learned about the concept of variability, have practiced the concepts through exercises, and will be able to model variability in requirements and design artifacts by using the orthogonal variability modeling approach (OVM).
Tutorial 9 (T9)
Domain-Specific Modeling and Code
Generation for Product Lines
Juha-Pekka Tolvanen
22 August 2006,
(Half Day - AM)
Current modeling languages provide surprisingly little support for automating product line development. They are either based in the code world using the semantically well-defined concepts of programming languages (e.g. UML) or based on an architectural view using a simple component-connector concept. In both cases, the languages themselves say nothing about a product family or its variants. This situation could be compared to that of a programmer being asked to write object-oriented programs where the language does not support any object-oriented concepts.
Most domain engineering approaches emphasize a language as an important mechanism to leverage and guide product development in product lines. Domain engineering results in creating a language (with related tools) for the variant specification and production that goes beyond configuring pre-built components. Previously, the effort for implementing textual or graphical languages and related tools was considerably high. This limited the use of domain engineering to a few cases only and hindered the use of true product family development methods. However, recent advances in metamodeling and related technology (e.g. metamodeling tools, Software Factory concept) as well as tools provide better support for language and generator creation. This tutorial describes how to create domain-specific languages and generators to automate product derivation. We inspect 20+ industry cases on language creation and demonstrate their use with hands-on examples. Industrial experiences of this approach show remarkable improvements in productivity (5-10 times faster variant creation) as well as capability to handle complex and large product lines (more than 100 product variants).
Tutorial 10 (T10)
The Scoping Game
Mark
Dalgarno
22 August 2006, (Half Day - AM)
Product Line Scoping is the activity of determining what products constitute the product line. i.e. the Product Line Scope. This tutorial will introduce and explore Product Line Scoping.
By the end of the tutorial participants should:
- Understand Scoping and why it is an essential Product Line activity.
- Understand Scoping as an economic decision driven by business objectives and involving Scope trade-offs.
- Understand the sources of information which underpin Scoping.
- Be able to identify stakeholders in the Scoping activity and relate this to their own organization.
- Be aware of alternative Scoping approaches.
- Understand Scoping as an iterative, on-going activity.
- Understand Scoping's position with respect to other Product Line activities.
- Know where to look for more information.
Tutorial 11 (T11)
Using Feature Models for
Product Derivation
Olaf Spinczyk, Holger Papajewski
22 August 2006,
(Half Day - AM)
The implementation of a software product line leads to a high degree of variability within the software architecture. For an effective development and deployment it is necessary to resolve variation points within the architecture and source code automatically during product/variant derivation. Given the complexity of most software systems tool support is necessary for these tasks. This tutorial shows how feature models combined with appropriate tools can provide this support. The importance of the separation of problem space modeling and solution space modeling is discussed. Concepts how to connect both spaces using constraints and/or generative approaches are shown. Furthermore, some typical patterns of variability in the solution space are shown and their automatic resolution in common languages like C/C++ and Java is demonstrated. Integration of code generators, aspect-oriented programming and software configuration management systems into the derivation process is also discussed. The tutorial is accompanied by demonstrations of the presented concepts with freely available tools.
Tutorial 12 (T12)
Lightweight Dependency Models
for Product Lines
Neeraj Sangal
22 August 2006, (Half Day - PM)
This tutorial will present a practical technique for managing the architecture of software product lines using Lightweight Dependency Models. We will demonstrate that the matrix representation used by these models provides a unique view of the architecture and is highly scalable compared to the directed graph approaches that are common today. We will also show a variety of matrix algorithms and transformations that can be applied to analyze and organize the system into a form that reflects the architecture and demonstrates the importance of managing dependencies in product lines.
During the tutorial, we will illustrate our approach by applying it to real applications each consisting of hundreds or thousands of files. We will show how dependency models can be created for product lines and how formal design rules can be specified to manage the evolution of these architectures. Finally, we will use the actual dependency models to demonstrate how architecture evolves and how it often begins to degrade.
Tutorial 13 (T13)
Transforming Legacy Systems
into Product Lines
Danilo Beuche
22 August 2006, (Half Day - PM)
Not every software product lines starts from the scratch, often organizations face the problem that after a while their software system is deployed in several variants and the need arises to migrate to systematic variability and variant management using a software product line approach. The tutorial will discuss issues coming up during this migration process mainly on the technical level, leaving out most of the organizational questions. The goal of the tutorial is to give attendees an initial idea how a transition into a software product line development process could be done with respect to the technical transition. The tutorial starts with a brief introduction into software product line concepts, discussing terms such as problem and solution space, feature models, versions vs. variants. Tutorial topics are how to choose adequate problem space modeling, the mining of problem space variability from existing artifacts such as requirements documents and software architecture. Also part of the discussion will be the need for separation of problem space from solution space and ways to realize it. A substantial part will be dedicated to variability detection and refactoring in the solution space of legacy systems.
Tutorial 14 (T14)
Feature Modularity in Software
Product Lines
Don Batory
22 August 2006, (Half Day - PM)
Feature Oriented Programming (FOP) is a design methodology and tools for program synthesis in software product lines. Programs are specified declaratively in terms of features. FOP has been used to develop product-lines in widely varying domains, including compilers for extensible Java dialects, fire support simulators for the U.S. Army, network protocols, and program verification tools. The fundamental units of modularization in FOP are program extensions (aspects, mixins, or traits) that encapsulate the implementation of an individual feature. An FOP model of a product-line is an algebra: base programs are constants and program extensions are functions (that add a specified feature to an input program). Program designs are expressions - compositions of functions and constants - that are amenable to optimization and analysis. This tutorial reviews core results on FOP: models and tools for synthesizing code and non-code artifacts by feature module composition, automatic algorithms for validating compositions, and the relationship between product-lines, metaprogramming, and model driven engineering (MDE).
Tutorial 15 (T15)
Generative Software
Development
Krzysztof Czarnecki
22 August 2006, (All Day)
Product-line engineering seeks to exploit the commonalities among systems from a given problem domain while managing the variabilities among them in a systematic way. In product-line engineering, new system variants can be rapidly created based on a set of reusable assets (such as a common architecture, components, models, etc.). Generative software development aims at modeling and implementing product lines in such a way that a given system can be automatically generated from a specification written in one or more textual or graphical domain-specific languages (DSLs).
In this tutorial, participants will learn how to perform domain analysis (i.e., capturing the commonalities and variabilities within a system family in a software schema using feature modeling), domain design (i.e., developing a common architecture for a system family), and implementing software generators using multiple technologies, such as template-based code generation and model transformations. Available tools for feature modeling and implementing DSLs as well as related approaches such as Software Factories and Model-Driven Architecture will be surveyed and compared. The presented concepts and methods will be demonstrated using a sample case study of an e-commerce platform.
