Tutorials

The following tutorials have been accepted:

T1: Successful Product Line Engineering – Experiences from the Real World (full-day), Monday
T2: Introduction to Software Product Lines (half-day), Monday morning
T3: Software Ecosystems (half-day), Monday morning
T4: Achieving Speed in Legacy Systems (half-day), Monday afternoon
T5: DSLs for Product Lines: Approaches, Tools, Experiences (half day) , Monday afternoon
T6: Management and Operation of a Software Product Line (half-day), Monday morning
T7: Production Planning in a Software Product Line Organization (half-day), Monday afternoon
T8: Leveraging Model Driven Engineering in Software Product Line Architectures (half-day), Monday afternoon
T9:Creating Domain-Specific Modeling Languages for Product Lines (half-day), Monday morning
T10: Introduction to Software Product Adoption (half-day), Friday afternoon
T11: Industry Trends in Systems and Software Product Line Engineering (half-day), Friday morning
T12: Transforming Legacy Systems into Software Product Lines (half-day), Friday afternoon
T13: Managing Requirements in Product Lines (half-day), Friday morning

T1

Successful Product Line Engineering – Experiences from the Real World (full-day)
Monday, 22.8.

Abstract
Product Line Engineering is a common approach to address a business with a family of related software products. Instead of having separated development projects for each product in the family, products are built using a shared set of core assets, such as reference architectures and common infrastructure and domain-specific components. Key drivers for PLE are the potential cost savings due to shared core assets, as well as new business opportunities by, for instance, supporting tight integration and improved interworking among members of the product family.

Successful PLE depends on many challenging factors. For instance, what is the ideal scope, what are the products that are part of the product line? What assets are considered common across all products and what assets are product-specific? Is a revolutionary approach better than an evolutionary approach? How can the variability amongst the products be managed effectively? What processes, methods, and technologies support PLE and what properties are required for the architecture and components that form the foundation of the product line? And what are the traps and pitfalls that can let a PLE approach fail?

In this tutorial we outline the experience made with PLE in several real world projects, ranging from the medical to the industry domain. Goal is to provide practical guidance for project managers and architects facing the "PLE challenge" to help making their PLE activities an economical and technical success.

Presenters
Frank Buschmann and Christa Schwanninger
frank.buschmann@siemens.com

T2

Introduction to Software Product Lines (half-day)
Monday, 22.8., morning

Abstract
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 PracticeSM, and describe approaches to applying the practices of the framework.

Presenter
Patrick Donohoe
pd@sei.cmu.edu

T3

Software Ecosystems (half-day)
Monday 22.8., morning

Abstract
Software ecosystems are the logical destination for any successful software product line. Once an organization has established a product line with a significant number of customers, there will be more requests from customers for functionality than what the organization can build itself. Also, independent solution provides and third party developers will increasingly ask for access to the platform in order to build customer (segment) specific solutions on top of the products and platform in the product line.

This tutorial provides the participants with an understanding of the forces leading to the creation of a software ecosystem around a successful software product line, a theoretical framework and taxonomy of software ecosystems, several industrial examples and cases and, depending on the length of the tutorial, several exercises to apply the principles to a specific case.

Presenter
Jan Bosch
jan@janbosch.com

T4

Achieving Speed in Legacy Systems (half-day)
Monday 22.8., afternoon

Abstract
The ability to rapidly respond to customer interest and to effectively prioritize development effort has been a long-standing challenge for mass-market software intensive products. This problem is exacerbated in the context of legacy products as functionality may easily fall over software asset and organizational boundaries with consequent losses in efficiency and nimbleness. Some companies facing these problems in their product line respond with a new development process. In this tutorial, we discuss an approach for achieving speed in legacy systems using self-organization and design thinking. We illustrate the approach using a case study, Intuit’s Quickbooks product line that combined agile software development, design thinking and self-organizing teams in a successful approach that provided a significant improvement in terms of responsiveness and accuracy of building customer value.

Presenter
Jan Bosch
jan@janbosch.com

T5

DSLs for Product Lines: Approaches, Tools, Experiences (half-day)
Monday, 22.8., afternoon

Abstract
The goal of this turorial is to show how Domain-Specific Languages fit into the over PLE approach, and how they relate to and integrate with feature models.

Domain-Specific Languages are languages narrowly focused on a particular problem domain. Compared to feature models they are more expressive, but possibly not as easy to use. Compared to source code, they are usually simpler, more targeted and hence easier to use - although not quite as flexible. DSLs can play an important role in PLE, filling the gap between configuration via feature models and low-level programming.

In this tutorial I will cover approaches, tools and experiences of using DSLs in PLE. I will start with briefly introducing DSLs and their role in PLE. We will then look at a real-world DSL that has been used to describe a product line of electrical devices. Next we will spend some time extending a DSL built with Eclipse Xtext to get a feel for the tool and the involved effort. After that we will look at and extend a DSL for robot control, that integrates nicely with the C programming language and feature models. This example is based on JetBrains MPS.

Presenter
Markus Voelter
voelter@acm.org

T6

Management and Operation of a Software Product Line (half-day)
Monday, 22.8., morning

Abstract
The goal of this tutorial is to provide information about both strategic and tactical actions needed for the continuing operation of a successful software product line organization. This tutorial will look beyond the issues of adoption to focus on the care and feeding of the on-going organization. Attendees will be able to raise their issues and learn how others are addressing those same concerns.

Presenters
John Mcgregor and Dirk Muthig
johnmc@cs.clemson.edu
dirk.muthig@lhsystems.com

T7

Production Planning in a Software Product Line Organization (half-day)
Monday, 22.8., afternoon

Abstract
Business and market goals drive an organization’s operation of a software product line strategy. Effective product production is critical to the success of that product line and must also be driven by those business and market goals. This tutorial outlines a method for coordinating the core asset development and product production.

Presenters
John Mcgregor and Gary Chastek
johnmc@cs.clemson.edu
gjc@sei.cmu.edu

T8

Leveraging Model Driven Engineering in Software Product Line Architectures (half-day)
Monday, 22.8., afternoon

Abstract
Model Driven Engineering (MDE) is a promising recent innovation in the software industry that has proven to work synergistically with Software Product Line Architectures (SPLA). It can provide the tools necessary to fully harness the power of Software Product Lines. The major players in the software industry including commercial companies such as IBM, Microsoft, standards bodies including the Object Management Group and leading Universities such as the ISIS group at Vanderbilt University are embracing this MDE/SPLA combination fully. IBM is spearheading the Eclipse Foundation including its MDE tools like the Eclipse Modeling Framework (EMF) and the Graphical Modeling Framework. Microsoft has also launched their Software Factories and DSL Toolkit into the MDE space. Top software groups such as the ISIS group at Vanderbilt are using these MDE techniques in combination with SPLAs for very complex systems. The Object Management Group is working on standardizing the various facets of MDE. All of these groups are capitalizing on the perfect storm of critical innovations today that allow such an approach to finally be viable. To further emphasize the timeliness of this technology is the complexity ceiling the software industry find itself facing wherein the platform technologies have increased far in advance of the language tools necessary to deal with them. This complexity ceiling is evident in today’s Software Product Lines.

The goal of this tutorial is to educate attendees on what MDE technologies are, how exactly they relate synergistically to Software Product Line Architectures, and how to actually apply them using an existing Eclipse implementation.

The benefits of the technology are so far reaching that we feel the intended audience spans technical managers, developers and CTOs. In general the target audience includes researchers and practitioners who are working on problems related to the design and implementation of SPLAs and would like to understand the benefits of applying MDE techniques towards SPLAs and leverage Eclipse as a framework to develop MDE solutions. The first half will be less technical than the second half where we cover the details of SPLA and MDE in action in complete detail showing patterns and code.

Presenters
Bruce Trask and Angel Roman
bruce.trask@mdesystems.com
angel.roman@mdesystems.com

T9

Creating Domain-Specific Modeling Languages for Product Lines (half-day)
Monday, 22.8., morning

Abstract
Domain-Specific Modeling (DSM) offers a language-based approach to raise the level of abstraction in order to speed up development work and set variation space already at specification and design phase. A metamodel, a language specification, sets the variation space more efficiently than parameter tables or feature models. With DSM, the models are made up of elements representing concepts that are part of the product family and its variation space. In a fair number of cases final products can be automatically generated from these high-level specifications.

This tutorial teaches how to define domain-specific languages for product lines: how to identify variability and capture it in the language specification; how to enforce the architecture and coding rules; what options are available for code generation; and what are the industry experiences from companies. The tutorial is based on industrial experience and case data from several companies, including EADS, Nokia, Panasonic and Polar, will be used throughout the tutorial.

Presenters
Juha-Pekka Tolvanen and Steven Kelly
jpt@metacase.com
stevek@metacase.com

T10

Introduction to Software Product Adoption (half-day)
Friday, 26.8., afternoon

Abstract
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. If an organization is sold on the concept, how is it to proceed? 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.

Presenters
Lawrence Jones and Linda Northrop
lgj@sei.cmu.edu
lmn@sei.cmu.edu

T11

Industry Trends in Systems and Software Product Line Engineering (half-day)
Friday, 26.8., morning

Abstract
For businesses to be competitive, today’s product development organizations must deliver a product line – a portfolio of similar products or systems with variations in features and functions – rather than just an individual product. As a result, a new generation of innovative Systems and Software Product Line (SPL) engineering approaches has emerged to play an increasingly important role. This tutorial will spotlight how mainstream forces are driving SPL approaches to take a holistic perspective that is deeply integrated into the systems and software engineering lifecycle.

The tutorial will include specific examples based on the SPL Lifecycle Framework and the 3-tiered SPL Methodology. This framework and methodology, created by BigLever Software, is being applied, adopted and offered as the preferred SPL solution by systems and software engineering tool vendors such as IBM Rational and Serena Software. The motivation for the framework and methodology is to ease the integration of tools, assets and processes across the full lifecycle – from requirements, to design, development and testing. The goal is to provide product line engineers with a common set of SPL concepts and constructs for all tools and assets, at every stage of the lifecycle, and to assure that product line processes flow cleanly from one lifecycle stage to another.

The tutorial will feature observations and first-hand experiences from successful large-scale SPL deployments on highly recognizable product lines, such as US Navy Aegis cruisers and destroyers engineered by Lockheed Martin, US Army live and simulated training systems engineered by General Dynamics, worldwide online vacation home rental e-Commerce systems engineered by HomeAway, and full SPL lifecycle support for all subsystems in all General Motors vehicles.

Presenter
Charles Krueger
ckrueger@biglever.com

T12

Transforming Legacy Systems into Software Product Lines (half-day)
Friday, 26.8., afternoon

Abstract
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, but also discusses some of the relevant organisational 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 modelling, the mining of problem space variability from existing artefacts 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.

Presenter
Danilo Beuche
danilo.beuche@pure-systems.com

T13

Managing Requirements in Product Lines (half-day)
Friday, 26.8., morning

Abstract
Many organizations develop software or software –intensive products, which are can be seen as variants or members of a product line. Often the market demands variability and the software organization expects productivity benefits from reuse. In any case, complexity of the software development increases. Requirements management plays a central role in this, when it comes to mastering the complexity.

The tutorial aims at providing the essential knowledge for successfully running requirements management for product lines and variant rich development scenarios. Besides explaining methods also information about implementing the methods with standard tools is given.

Presenter
Danilo Beuche
danilo.beuche@pure-systems.com