The Third Software
Product Line Conference
Conference Tutorials
John D. McGregor
Clemson University
Tutorials Chair
SPLC 2004
The Third Software
|
SPLC 2004 |
The SPLC2004 will host fourteen conference tutorials:
Using Domain-Specific Languages, Patterns, Frameworks, and Tools to
Assemble Applications
Jack
Greenfield, Microsoft Corporation, Redmond, WA.
Increasingly complex and rapidly changing requirements and technologies are making application development increasingly difficult. This half-day tutorial explores this phenomenon and presents the Software Factory pattern for building languages, patterns, frameworks, and tools for specific domains, such as user interface construction or database design. We then explore innovations, such as adaptive assembly, software product lines, and model-driven development, that reduce the cost of implementing the pattern, making it cost-effective for narrower and more specialized domains, such as B2C application development and business process automation. We introduce the concept of the software schema, a network of viewpoints describing artifacts comprising the members of a family of software products, and we show how mappings between these viewpoints can be used to provide constraints supporting model transformation and self-organizing processes. Finally, we discuss the formation of software supply chains and show how the Software Factory pattern distributes across organizational boundaries.
This tutorial is based on the book Software Factories: Assembling Applications with Languages, Patterns, Frameworks and Tools, by Jack Greenfield and Keith Short, to be published by John Wiley and Sons in July 2004.
Tutorial Objective
Participants will learn about the methods,
practices, and technologies used in the development of software factories,
including commonality and variability analysis, concrete and abstract syntax
definition, model validation, model transformation, and software product line
engineering.
Product Line Analysis
Gary
Chastek and Patrick Donohoe, Software
Engineering Institute, Carnegie Mellon University, Pittsburgh, PA.
Product line analysis (PLA) is early requirements engineering for a product line of software-intensive systems. It encompasses the rapid elicitation, analysis, specification, and verification of the requirements for a product line. The premise of product line analysis is that a sound initial understanding of the problem to be solved is essential before an organization embarks on a software product line as a solution.
This tutorial provides practitioners with a practical introduction to product line requirements modeling. It describes the semantics, properties, and interrelationships of the PLA work products that constitute a model of the product line requirements and provides guidance on their construction and use. A running example, based on home automation systems, illustrates PLA concepts.
The goal of the tutorial is to provide attendees with an understanding of how to capture and represent product line requirements in a systematic, repeatable way, and in a form that can be easily communicated to product line architects and product builders. The intended audience is practitioners (i.e., the product line requirements engineers), product line architects, and technology developers interested in creating supporting tools. Attendees are assumed to have some familiarity with software product lines and software analysis. Familiarity with object technology, including object modeling and use cases, is also assumed.
This is a half-day introduction to product line analysis. It provides a quick overview rather than a detailed description. By completing this tutorial, attendees should be able to
Industrial-Strength Software Product line Engineering
John Klein,
Deborah Hill, and
David Weiss, Avaya Labs, Basking Ridge,
NJ.
Software product line engineering is one of the few approaches to software engineering that shows promise of improving software productivity by factors of 5 to 10. But, there are still relatively few examples of its successful application on a large-scale project, due in part to the complexity of the problem of initiating a product line engineering project and to the many factors that must be addressed for such a project to be successful. Practitioners and researchers alike are confronted with issues such as the following:
Tutorial Objectives
This tutorial draws on experience in introducing and sustaining product line engineering in Lucent Technologies and Avaya to answer such questions. Participants will take away an understanding of what drives a large software development organization to use product line engineering, the obstacles that can be encountered in putting product line engineering theory into practice, and practical approaches to overcoming such obstacles in a systematic way. Participants will learn both technical and organizational aspects of the problem. For example, the tutorial discusses areas that are critical to success in product line engineering but typically not covered by theory, such as who must be convinced to use product line engineering and what arguments to use. Finally, participants should leave the tutorial with ideas on how to transition a large organization to product line engineering while it is in the midst of developing and delivering products.
Participants will receive an inside look at an organization that is transitioning into product line engineering on a large scale. Success in such a project depends on both technical issues in creating and evolving a product line, and organizational issues in transforming an organization to be compatible with the product line engineering process.
Tutorial Approach
The tutorial will be conducted as a series of lecture and interactive sessions describing
The tutorial covers both theory and practice, showing how the theory is converted into the practice, how the theory guides the practice, and how the theory is refined as a result of the practice. The theory comes from the Family-oriented Abstraction, Specification, and Translation (FAST) process, a trial of which was first conducted on a small scale in Lucent Technologies Bell Laboratories. The process is now being applied on a large scale in Avaya Laboratories. The project has faced all of the typical pressures seen in software development organizations today: pressure to reduce costs, to meet time-to-market deadlines, to improve quality, to introduce a more efficient software development process without disrupting current development projects, and to move into new markets that introduce greater variability in the product line.
Quality Assurance for Software Product Lines
Ronny Kolb and
Dirk Muthig, Fraunhofer
Institute for Experimental Software Engineering (IESE), Kaiserslautern,
Germany.
The product line approach to software development is based on the systematic, large-scale reuse of development artifacts such as architecture, design, and components between a set of functional similar products. It promises, among other things, to shorten the development time of software systems and to significantly reduce development and maintenance costs. To achieve the promised improvements, however, the components and artifacts intended for reuse must be of high quality. Therefore, more than for traditional software development, quality assurance becomes a very crucial part of every product line effort.
Even though quality assurance has become not only more critical for software product lines, but also more complex due to the special properties of product lines such as genericity of software components, research in the field of software product lines to date has focused primarily on analysis, design, and implementation. In particular, the quality assurance challenges that arise in a product line context have been addressed insufficiently so far, and there is little guidance for product line organizations on how to systematically assure the quality of their product lines and reusable artifacts.
The overall goal of the tutorial is to provide an understanding of the problem of quality assurance in the context of software product lines and its importance for successful product line development. In particular, the tutorial aims at providing attendees with a detailed understanding of how the quality assurance process for product lines and generic software components needs to be different from traditional software systems and how quality assurance can be performed in the context of software product lines. To this end, the tutorial provides a discussion of the difficulties and challenges of quality assurance for software product lines and investigates the implications of product lines and reusable components on quality assurance. Finally, the tutorial aims to provide an understanding of existing quality assurance techniques and methods and how they can be applied in a product line context.
The tutorial addresses industrial practitioners, as well as applied researchers, working in the area of quality assurance or software product lines. In particular, the tutorial provides researchers with a concise overview of the current state of the art of quality assurance in the context of software product lines. In addition, the tutorial presents relevant issues and approaches in the area of quality assurance for software product lines, while providing industrial practitioners with a profound understanding of best practices they can apply.
Product Line Architectures for Global Software Development
Daniel J. Paulish, Roman Pichler,
and Wolfgang Kuhn, Siemens Corporate Research, Inc., Princeton, NJ.
This half-day tutorial discusses how product line practices can be applied to software projects with development teams distributed around the world. Software products are growing in complexity, and the development organizations that implement new features are growing in staff size. Business managers are seeking new approaches, such as offshoring and outsourcing, to get new software products to market quicker, while reducing their overall development investments. Siemens has been performing research to decompose large-scale requirements into a well-structured set of software components that can be developed in parallel among globally distributed development teams. This tutorial describes an approach using product line architecture methods for multi-site development projects in which software components are commissioned by a central product management and engineering organization for development at distributed sites.
As a participant in this tutorial, you will learn product line approaches based on best practices for developing your software products using globally distributed development organizations. Our approach for global development consists of improved practices in three key areas:
A central product management and engineering team controls the requirements model and high-level product architecture. The requirements model and architecture are designed such that component sizes are defined to be relatively small with a maximum specified size in terms of lines of code (LOC), function points, development time, and development effort. The distributed development teams are constrained with respect to functionality, delivery schedule, effort, and schedule for developing their commissioned components. However, they are free to use any local agile processes as long as they meet the constraints. Central product management and engineering synchronize the concurrent development of the planned components and their functionality and are responsible for component acceptance testing and integration.
This tutorial is oriented towards experienced software engineers, architects, and project and technical managers who are involved with planning or executing distributed development projects. The goal of the tutorial will be to communicate product line best practices that will help minimize the risks associated with global software development.
Architecture-Centric Software Engineering
Jan Bosch, University of Groningen,
Department of Computing Science, The Netherlands.
Many software organizations are in the process of moving from project- and product-centric software engineering to architecture-centric software engineering. Typically, this move is made for two reasons: (1) the architecture allows for a clear breakdown in parts, whereas a project-centric approach easily leads to a monolithic system and (2) the organization is interested in exploiting the commonalities between its products or systems.
This tutorial addresses this development by providing an overview and in-depth treatment of the issues around architecture-centric software engineering [1]. The first topic is concerned with the design of software architectures in the presence of existing components and infrastructure (e.g., designing the architecture in a top-down or bottom-up fashion). Two issues discussed in the context of architecture design are the notion of architecture design decisions and software variability management. Architecture design decisions lack first-class representation in the architecture descriptions. We are developing solutions to address this. Software variability management is concerned with explicitly managing the points of variation in software artifacts and in the software architecture in particular.
The second topic is the evaluation and assessment of software architectures. As architectural changes late in a development project or during evolution are often prohibitively expensive, verifying that the architecture has the right quality properties is of great importance. The aim is to, preferably quantitatively, predict the qualities of a software system based on its software architecture.
The final topic of the tutorial is concerned with the use of the software architecture, especially in the context of software product families and highly configurable products. In this part, not only the technical aspects, but also the process and organizational viewpoints are discussed, and the relation between the different dimensions is presented. In addition, evaluation models and adoption approaches are discussed. The topics are illustrated extensively by examples and experiences from many industrial cases.
Reference
Software Variability Management
Jan Bosch, University of Groningen,
Department of Computing Science, The Netherlands.
In a variety of approaches to software development, software artefacts are used in multiple contexts or for various purposes. The differences lead to so-called variation points in the software artefact. During recent years, the amount of variability supported by a software artefact is growing considerably, and its management is developing as a main challenge in the development, usage, and evolution of software artefacts. Areas where the management of variability is evolving as a challenge include software product families [1], component-based software development, object-oriented frameworks, and configurable software products such as planning systems for enterprise resources. For example, in a typical software product family, the number of variation points may easily range in the thousands.
Software variability is the ability of a software system or artefact to be changed, customized, or configured for use in a particular context [2]. A high degree of variability allows the use of software in a broader range of contexts (i.e., the software is more reusable). Variability can be viewed as consisting of two dimensions: space and time. The space dimension is concerned with the use of software in multiple contexts (e.g., multiple products in a software product family). The time dimension is concerned with the ability of software to support evolution and changing requirements in the software's various contexts.
Successful management of variability in software artefacts leads to better customizable software products that are, in turn, likely to result in higher market success. In the information systems domain, the products are more easily adaptable to the needs of different user groups; in the embedded systems domain, the software can be more easily configured to work with different hardware and environmental constraints.
The tutorial first establishes the importance of software variability management, among other things through industrial examples consisting of thousands of variation points and dependencies. Second, the tutorial defines the concept of variability and discusses notational and visualization aspects, including the COVAMOF model. Third, we discuss the assessment of software artefacts for variability (i.e., COSVAM) and the design of architectures and components for variability. Fourth, the use of variation points is presented (e.g., while configuring instantiated software artefacts). Finally, some advanced issues including variation versus composition are discussed.
References
Designing Software Product Lines with the Unified Modeling Language
(UML)
Dr. Hassan Gomaa, Department
of Information and Software Engineering, George Mason University, Fairfax,
Virginia.
This tutorial addresses how to develop object-oriented requirements, analysis, and design models of software product lines using the Unified Modeling Language (UML) 2.0 notation. During requirements modeling, the tutorial covers how to develop kernel, optional, and alternative use cases for defining the software functional requirements of the system. The tutorial also describes the feature model for capturing product line requirements and how it relates to the use case model. During analysis, the tutorial covers how to develop static models for defining kernel, optional, and variant classes and their relationships. It also describes how to create dynamic models in which interaction models describe the dynamic interaction between the objects that participate in each kernel, optional, and alternative use case, and in which statecharts define the state-dependent aspects of the product line. The tutorial then covers how to develop component-based software architecture for the product line using the new UML 2.0 notation for structured classes and composite structure diagrams. That notation allows components, ports, and connectors, as well as provided and required interfaces, to be depicted. The tutorial gives an overview of the architectural structure patterns and architectural communication patterns that can be used in designing component-based product lines. The tutorial is illustrated by several examples and based on the book by Hassan Gomaa titled Designing Software Product Lines with UML to be published by Addison-Wesley in July 2004.
Developing a Measurement Program for Software Product Lines
Sholom Cohen, Dave Zubrow, and
Gary Chastek, Software Engineering
Institute, Carnegie Mellon University, Pittsburgh, PA.
Product line management should use measurement to anticipate the future rather than to simply record the past. The benefit and value of software measurement for product lines comes from the decisions and actions taken to support the product line in response to analysis of the data, not from the collection of the data. Addressing this management need is the primary goal of this tutorial.
Implementing measures for a software product line requires coordination across multiple projects. They must establish common goals and develop measures to track results on individual projects. We have developed this tutorial to help product line managers, software product development managers, software core asset development managers, and Software Engineering Process Group (SEPG) members support that activity. The tutorial will help the audience set measurable goals and determine if the software product line is producing the expected results. To benefit from the tutorial, attendees need no prior experience in measurement.
While the half-day format does not provide hands-on interaction, it will describe three sets of activities to develop a measurement program for software product lines:
By following this approach, the risk of having data gathered, but not used, is minimized.
The tutorial also describes a range of measurements relevant to software product lines. The measures suggested here range from relatively mature to those whose general utility has yet to be validated. Therefore, a product line organization needs to assess its ability to generate the measures and the value those measures are likely to return to the organization. In most cases, an organization may wish to start with a subset of the product line measures described.
A case study in establishing a software product line measurement program illustrates the approach and use of software product line measurements. The organization covered in the case study established a Software Measurement Team to develop and monitor a measurement program. That measurement team includes representatives from programs using a core asset base. Four projects currently contribute to the measurement program.
Starting Product Lines (I) — Systematic Product Line Planning
and Adoption
Klaus
Schmid and Isabel John,
Fraunhofer IESE, Sauerwiesen 6, 67661 Kaiserslautern, Germany.
To successfully and effectively adopt a software product line approach, the transition must be well aligned to the specific product line situation. As more and more organizations aim at a product line transition, this becomes increasingly an issue. To successfully and effectively adopt a software product line approach, a thorough analysis of the economic implications of the adoption must be performed, and the product line introduction needs to be adequately planned. This requires a precise picture of the product line through product analysis and modeling. A thorough analysis of the economic implications of the adoption must be performed, and the introduction of the product line needs to be correspondingly planned. Of course, such a transition has serious ramifications for the component structure of the software. We will discuss these consequences and show how the economic analysis itself can be used as a basis for deriving an adequate structure for the software. Thus, this tutorial provides a concise overview of the current state of the art of product line planning and adoption that is aimed at both researchers and practitioners of product line development.
Structure
The tutorial covers the following topics:
Starting Product Lines (II) — Product Line Analysis and
Modeling
Isabel John
and Klaus Schmid,
Fraunhofer IESE, Sauerwiesen 6, 67661 Kaiserslautern, Germany.
Product line engineering is recognized as a viable approach to large-scale software reuse. This tutorial provides a concise overview of the current state of the art of product line analysis and modeling and aims at giving an understanding of how to identify, analyze, and model commonalities and variabilities. It also provides an overview of the vast range of existing techniques for product line analysis and modeling. In particular, this tutorial provides researchers with a better understanding of the breadth of relevant issues and approaches, while providing industrial practitioners with a profound understanding of best practices they can apply. As the systematic identification and description of commonalities and variabilities are key in product line development to achieving successful reuse, the adequate selection or extension of modeling techniques can be regarded as a key to the overall goal of the SPLC. The modeling tutorial is a half-day tutorial, however, it can be combined with the tutorial titled "Starting Software Product Lines (I) - Systematic Product Line Planning and Adoption" to yield a full-day tutorial covering the early phases of product line development.
Structure
The tutorial covers the following topics:
Generative Software Development
Krzysztof Czarnecki,
University of Waterloo, Canada.
Abstract
System family engineering seeks to exploit the
commonalities among systems from a given problem domain while managing the
variabilities among them in a systematic way. In system family engineering, new
system variants can be created rapidly based on a set of reusable assets (such
as a common architecture, components, models, etc.) [1]. Generative software
development aims at modeling and implementing system families 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 [2–8]. 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. The relationship to model-driven development will be also
discussed. The presented concepts and methods will be demonstrated using a case
study.
References
1. Clements, P., Northrop, L.M.: Software Product
Lines: Practices and Patterns. Addison-Wesley (2001)
2. Neighbors, J.M.:
Software Construction using Components. PhD thesis, Department of Information
and Computer Science, University of California, Irvine (1980) Technical Report
UCI-ICS-TR160; available at http://www.bayfronttechnologies.com/ thesis.htm.
3. Cleaveland, J.C.: Building application generators. IEEE Software 5
(1988) 25–33
4. Weiss, D.M., Lai, C.T.R.: Software Product-Line
Engineering: A Family-Based Software Development Process. Addison-Wesley (1999)
5. Czarnecki, K., Eisenecker, U.W.: Generative Programming: Methods, Tools,
and Applications. Addison-Wesley (2000)
6. Cleaveland, C.: Program
Generators with XML and Java. Prentice-Hall (2001)
7. Batory, D., Johnson,
C., MacDonald, B., von Heeder, D.: Achieving extensibility through
product-lines and domain-specific languages: A case study”. ACM
Transactions on Software Engineering and Methodology (TOSEM) 11 (2002)
191–214
8. Greenfield, J., Short, K.: Software Factories: Assembling
Applications with Patterns, Models, Frameworks, and Tools. Wiley (2004) To be
published.
An Introduction to Software Product Lines
Paul Clements and
Linda Northrop, Software Engineering
Institute, Carnegie Mellon University, Pittsburgh, PA
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 their family 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 provides an overview of software product lines. It covers the basic concepts of software product lines, the essential software engineering and management practices, and a sampling of product line practice patterns that help organizations apply the practices in a way best suited to their individual needs. The concepts are illustrated with a detailed case study of an actual organization's experiences with the software product line approach. This tutorial is based on the book Software Product Lines: Practices and Patterns by Paul Clements and Linda Northrop.
This tutorial is appropriate for managers and practitioners. Participants should have experience in designing and developing software-intensive systems and some familiarity with modern software engineering concepts and management practices. The goal of the tutorial is for participants to understand the essential activities and practices involved in a software product line approach and to appreciate software product lines as an effective reuse strategy.
Adopting Software Product Lines
Linda Northrop and Lawrence
Jones, Software Engineering Institute, Carnegie Mellon University, Pittsburgh,
PA
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. It begins with a discussion of software product line adoption issues and then presents the Adoption Factory, a variant of the Factory pattern. The Factory pattern describes the entire product line organization. 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 process improvement initiatives.
The objective of the tutorial is to acquaint participants with product line adoption barriers and two ways to overcome them:
Participants should have experience in designing and developing software-intensive systems and familiarity with software product line concepts.
|
|
|
