Software Product Lines: Concepts and Implementation

Questions

• How to support different functionality for different customers, but still maintain a cohesive code base?

  

• How does the Linux kernel implement 13,000 options configurable at compile time? How can we find bugs in 2^13000 configurations?
• How to design a platform that many third-party developers can contribute to?
  
• How to build extensible and reusable platforms? How do I structure and convince my team?
  
• What has the air condition to do with the electronic parking break? Can feature interactions be controlled or avoided?
  
• I could create an option here, should I? Should I really redesign the architecture or do I just use a preprocessor to inject code?
  
• You can write a single program. But can you codevelop and coordinate many products in a product lines?
  

Overview

Variability and reuse are increasingly important in developing large-scale and reliable, but also customized software systems. The goal of software product line engineering is the large-scale strategic reuse of functionality across multiple software products within a domain, such that different software configurations tailored for different customers or use cases are derived from a common code base. This course is designed to walk students through the entire process of developing an maintaining software product lines and highly configurable software systems, including:

• studying requirements with domain analysis,
  
• modeling and reasoning about configuration spaces,
  
• strategically planning reusable implementations (architecture),
  
• various implementation strategies and their tradeoffs (frameworks, components, conditional compilation, code generators, feature-oriented programming, aspect-oriented programming, and others), and
  
• challenges regarding quality assurance and feature interactions. 

The course will mostly look at technical issues, but also cover organizational challenges, such as scoping, team management, and introducing product-line practices. We will study how highly configurable systems are developed and maintained in industry and open source and look at recent research results. The goal of this course is to help students require the background and theoretical and practical knowledge to do research in this field and to consult on reuse projects in practice.

Throughout the lecture we will look at case studies, investigating existing (mostly open source) system and study their practices in developing variations and extensible platforms. Among others, we will study the variability mechanisms in the Linux kernel, in Android, in Eclipse, and in Debian.

Coordinates

Lectures: Monday/Wednesday 9:00-10:20 a.m. in GHC 4211
No recitation

The instructor has an open door policy: If his office door is open and no-one else is meeting with him, he is happy to answer any course-related questions. For appointments, send an email.

Schedule

The following schedule gives a rough outline of the topics of the course, but will be updated throughout the semester.

Date	Topic	Reading Assignment	Homework Due
Aug 31	Introduction, Organization, Domain Engineering
Sep 2	Feature and decision models	[FOSPL, p. 3-31]
Sep 7	No class (Labor day)
Sep 9	Case study discussion	[FOSPL, Ch. 2] [FODA, Sec 1 + 3-5, skim 7]	hw 1 Case studies
Sep 14	Analysis of feature models	[B05] [BSR10, Sec. 5]
Sep 16	Product management, scoping	[C02]
Sep 21	No class
Sep 23	No class		hw 2 Domain analysis
Sep 28	Variability in requirements	[SAS12, Sec 1-4]
Sep 30	Version control systems, Parameters	[FOSPL, Ch. 5.1] [DRBD13]
Oct 5	Design patterns, frameworks, platforms, components and services	[FOSPL, Ch. 4]	hw 3 Base implementation
Oct 7	Design patterns, frameworks, platforms, components and services (continued)	[O02] [B09]
Oct 12	Case Studies: Android, Debian	[AJB+14] [ASD+12]	hw 4 Framework implementation
Oct 14	Midterm
Oct 19	Build systems, preprocessors	[FOSPL, Ch. 5] [F97]
Oct 21	Case Study: Linux kernel	[MKR+15] [MB05]
Nov 26	No class		hw 5 Preprocessor implementation
Oct 28	Tradeoff and maintenance discussion	[FOSPL, Ch. 3]
Nov 2	Advanced Concepts: Feature-Oriented Programming	[FOSPL, Ch. 6.1] [AKL13, Sec. 1-3]
Nov 4	Advanced Concepts: Aspect-Oriented Programming	[FOSPL, Ch. 6] [ADTH09]
Nov 9	Generators, DSLs, MDD	[VV11] [S06]	hw 6 Open source analysis
Nov 11	No class
Nov 16	Quality assurance: Sampling	[GC11] [TLD+11]
Nov 18	Quality assurance: Testing	[PM06] [GDS12]
Nov 23	Quality assurance: Advanced concepts	[TBKC06] [FOSPL, Ch. 10]	hw 7 FOP/AOP implementation
Nov 25	No class (Thanksgiving)
Nov 30	Feature interactions	[NLN08] [FOSPL, Ch. 9]
Dec 2	No class
Dec 7	Adoption and evolution	[CK02]
Dec 9	Project presentations		project Project presentation and writeup

Readings

• [FOSPL] Apel, S., Batory, D., Kästner, C., & Saake, G. (2013). Feature-Oriented Software Product Lines. Berlin: Springer. link
• [FODA] Kang, K. C., Cohen, S. G., Hess, J. A., Novak, W. E., & Peterson, A. S. (1990). Feature-oriented domain analysis (FODA) feasibility study (No. CMU/SEI-90-TR-21). Carnegie-Mellon Univ Pittsburgh Pa Software Engineering Inst. link
• [B05] Batory, D. (2005). Feature models, grammars, and propositional formulas (pp. 7-20). Springer Berlin Heidelberg. link
• [BSR10] Benavides, D., Segura, S., & Ruiz-Cort\E9s, A. (2010). Automated analysis of feature models 20 years later: A literature review. Information Systems, 35(6), 615-636. link
• [CVL] Common Variability Language (CVL), OMG Revised Submission, Chapter 7 link
• [C02] Paul C. Clements. On the Importance of Product Line Scope. In Software Product-Family Engineering. pp 70-78. Springer. 2002 link
• [SAS12] Shaker, P., Atlee, J. M., & Wang, S. (2012, September). A feature-oriented requirements modelling language. In Requirements Engineering Conference (RE), 2012 20th IEEE International (pp. 151-160). IEEE. link
[DRBD13] Dubinsky, Y.; Rubin, J.; Berger, T.; Duszynski, S.; Becker, M.; Czarnecki, K., "An Exploratory Study of Cloning in Industrial Software Product Lines," in 17th European Conference on Software Maintenance and Reengineering (CSMR), pp.25-34, 2013 link
• [O02] Van Ommering, Rob. "Building product populations with software components." Proceedings of the 24th international conference on Software engineering. ACM, 2002. link
• [B09] Bosch, Jan. "From software product lines to software ecosystems." Proceedings of the 13th International Software Product Line Conference. 2009. link
• [AJB+14] Antkiewicz, M., Ji, W., Berger, T., Czarnecki, K., Schmorleiz, T., Lämmel, R., et al. (2014, May). Flexible product line engineering with a virtual platform. In Companion Proceedings of the 36th International Conference on Software Engineering (pp. 532-535). ACM. link
• [ASD+12] Artho, C., Suzaki, K., Di Cosmo, R., Treinen, R., & Zacchiroli, S. (2012, June). Why do software packages conflict?. In Proceedings of the 9th IEEE Working Conference on Mining Software Repositories (pp. 141-150). IEEE Press. link
• [F97] Favre, Jean-Marie. "Understanding-in-the-large." Program Comprehension, 1997. IWPC'97. Proceedings., Fifth Iternational Workshop on. IEEE, 1997. link
• [MB05] Bill McCloskey and Eric Brewer. 2005. ASTEC: A new approach to refactoring C. In Proceedings of the 10th European Software Engineering Conference/International Symposium on Foundations of Software Engineering (ESEC/FSE-13). ACM, New York, NY, USA, 21-30. link
• [MKR+15] Medeiros, F., Kästner, C., Ribeiro, M., Nadi, S., & Gheyi, R. The Love/Hate Relationship with the C Preprocessor: An Interview Study. In Proc. 29th European Conference on Object-Oriented Programming (ECOOP 2015), 12, 40. link
• [KAL13] Apel, Sven, Christian Kastner, and Christian Lengauer. "Language-independent and automated software composition: The FeatureHouse experience." Software Engineering, IEEE Transactions on 39, no. 1 (2013): 63-79. link
• [ADTH09] Adams, Bram, Wolfgang De Meuter, Herman Tromp, and Ahmed E. Hassan. "Can we refactor conditional compilation into aspects?." In Proceedings of the 8th ACM international conference on Aspect-oriented software development, pp. 243-254. ACM, 2009. link
• [VV11] Voelter, M., & Visser, E. (2011, August). Product line engineering using domain-specific languages. In Software Product Line Conference (SPLC), 2011 15th International (pp. 70-79). IEEE. link
• [S06] Schmidt, D. C. (2006). Guest editor's introduction: Model-driven engineering. Computer, 39(2), 0025-31. link
• [GC11] Garvin, Brady J., and Myra B. Cohen. "Feature interaction faults revisited: An exploratory study." In Software Reliability Engineering (ISSRE), 2011 IEEE 22nd International Symposium on, pp. 90-99. IEEE, 2011. link
• [TLD+11] Tartler, Reinhard, Daniel Lohmann, Christian Dietrich, Christoph Egger, and Julio Sincero. "Configuration coverage in the analysis of large-scale system software." In Proceedings of the 6th Workshop on Programming Languages and Operating Systems, p. 2. ACM, 2011. link
• [PM06] Pohl, Klaus, and Andreas Metzger. "Software product line testing." Communications of the ACM 49, no. 12 (2006): 78-81. link
• [GDS12] Greiler, Michaela, Arie Van Deursen, and Margaret-Anne Storey. "Test confessions: a study of testing practices for plug-in systems." In Software Engineering (ICSE), 2012 34th International Conference on, pp. 244-254. IEEE, 2012. link
• [TBKC06] Thaker, Sahil, Don Batory, David Kitchin, and William Cook. "Safe composition of product lines." In Proceedings of the 6th international conference on Generative programming and component engineering, pp. 95-104. ACM, 2007. link
• [NLN08] Nhlabatsi, Armstrong, Robin Laney, and Bashar Nuseibeh. "Feature interaction: the security threat from within software systems." Progress in Informatics 5 (2008): 75-89. link
• [CK02] Clements, Paul, and Charles Kreuger. "Point/Counterpoint." IEEE Software 4 (2002): 28-31. link

Course Syllabus and Policies

Slides, supplementary documents, assignments, grades, and announcements can be found on blackboard.

Prerequisites: Basic programming skills (preferably in Java or C) and basic software engineering knowledge (process, requirements, ...)

Communication: We make announcements through blackboard. The instructor holds weekly office hours and is reachable by email. See also open door policy above.

Grading: Evaluation will be based on the following approximate percentages: 30% assignments, 30% project, 30% exams, 10% participation.

Textbooks: The course is largely based on the textbook S. Apel, D. Batory, C. Kästner, and G. Saake. Feature-Oriented Software Product Lines: Concepts and Implementation. Berlin/Heidelberg: Springer-Verlag, 2013 (electronic copy available through CMU library). In addition, we will assign or recommend supplementary readings with each chapter, which we will provide via blackboard.

Time management: This is a 12-unit course, and it is our intention to manage it so that you spend close to 12 hours a week on the course, on average. In general, 3 hours/week will be spent in class and 9 hours on assignments. Please feel free to give the course staff feedback on how much time the course is taking for you.

Late work policy: Late work will receive feedback but no credit. Students may use up to 5 late days throughout the semester. Exceptions to this policy will be made only in extraordinary circumstances, almost always involving a family or medical emergency with your academic advisor or the Dean of Student Affairs requesting the exception on your behalf. Accommodations for travel might be possible if requested at least 3 days in advance.

Academic honesty and collaboration: The usual policies apply, especially the University Policy on Academic Integrity. Copying files or parts of files with or without modifications is not acceptable; making your work available to others is not acceptable. Note that some assignments will be done in groups. We expect that group members collaborate but that groups work independently from other groups, not exchanging results. Within groups we expect that you are honest about your contribution to the group's work. In particular, it is inappropriate to cover for students who did not contribute to a group's result.