Analysis Strategies for Configurable Systems

A configurable system enables users to derive individual system variants based on a selection of configuration options. To cope with the often huge number of possible configurations, several analysis approaches (e.g., for verification of configurable systems) implement different strategies to account for configurability. One popular strategy—often applied in practice—is to use sampling (i.e., analyzing only a subset of all system variants). While sampling reduces the analysis effort significantly, the information obtained is necessarily incomplete as some variants are not analyzed. A second strategy is to identify the common parts and the variable parts of a configurable system and analyze each part separately (called feature-based strategy). As a third strategy, researchers have begun to develop family-based analyses. Family-based approaches analyze the code base of a configurable system as a whole, rather than the individual variants or parts of the system, this way exploiting similarities among individual variants to reduce analysis effort. Each of these three strategies has advantages and disadvantages, which might even prevent its application (e.g., the family-based strategy typically needs much main memory). The goal of this thesis is to enable the efficient analysis of configuable systems, even if existing strategies fail (e.g., the family-based strategy, because of memory limitations). To this end, we designed a framework that models the key aspects of configurable-system analysis strategies, independent of their implementation and of the analyses techniques (e.g., type checking or model checking). Guided by our model, we developed a number of analysis strategies for configurable systems. To learn about advantages and disadvantages of individual strategies, we compared these in a series of empirical studies. In particular, we developed and evaluated a model-checking analysis and a data-flow analysis for configurable systems. One of our key findings is that family-based analysis outperforms most sampling heuristics with respect to analysis time, while being able to make definite statements about all variants of a configurable system. Furthermore, we identified advantages and disadvantages of analysis strategies and how to mitigate them by combining strategies. In our endeavor, we identified two key problems that are common to configurable-system analyses, and we developed supporting techniques to solve them. These techniques are general and are applicable beyond our research. In particular, we developed presence-condition simplification and variability encoding. Presence-condition simplification provides a simple method to reduce the size of the output or the internal data structure of configurable-system analyses. Variability encoding provides a means for transforming compile-time variability to run-time variability, which enables many family-based analyses. Our key contributions are the model of analysis strategies for configurable systems and the corresponding empirical comparisons of strategies. Our findings are backed by empirical studies, which helped broaden the community knowledge on analyses of configurable systems (indicated by citations). For these evaluations, we prepared several subject systems, which have also been used already by other researchers. Furthermore, we developed several analysis tools and demonstrated their feasibility in practical application scenarios based on code from, for example, the Linux kernel. Our tools are based on variability-aware optimizations that enable levels of scalability on configurable systems that were not possible with other tools before.

[1]  H. D. Rombach,et al.  The Goal Question Metric Approach , 1994 .

[2]  Stephan Merz,et al.  Model Checking , 2000 .

[3]  Carsten Sinz,et al.  Configuration Lifting: Verification meets Software Configuration , 2008, 2008 23rd IEEE/ACM International Conference on Automated Software Engineering.

[4]  Sven Apel,et al.  Introducing Binary Decision Diagrams in the explicit-state verification of Java code , 2011 .

[5]  Christel Baier,et al.  Probabilistic model checking for energy analysis in software product lines , 2013, MODULARITY.

[6]  Kathi Fisler,et al.  Verifying cross-cutting features as open systems , 2002, SIGSOFT '02/FSE-10.

[7]  David Buchfuhrer,et al.  The complexity of Boolean formula minimization , 2008, J. Comput. Syst. Sci..

[8]  Daniel Kroening,et al.  A Tool for Checking ANSI-C Programs , 2004, TACAS.

[9]  Mark Ryan,et al.  Feature integration using a feature construct , 2001, Sci. Comput. Program..

[10]  Krzysztof Czarnecki,et al.  Feature-to-Code Mapping in Two Large Product Lines , 2010, SPLC.

[11]  Maurice H. ter Beek,et al.  From EU Projects to a Family of Model Checkers - From Kandinsky to KandISTI , 2015, Software, Services, and Systems.

[12]  Sven Apel,et al.  Language-Independent and Automated Software Composition: The FeatureHouse Experience , 2013, IEEE Transactions on Software Engineering.

[13]  Dirk Beyer Software Verification and Verifiable Witnesses - (Report on SV-COMP 2015) , 2015, TACAS.

[14]  Patrick D. McDaniel,et al.  Semantically rich application-centric security in Android , 2012 .

[15]  Sven Apel,et al.  Variability encoding: From compile-time to load-time variability , 2016, J. Log. Algebraic Methods Program..

[16]  Maurice H. ter Beek,et al.  Using FMC for family-based analysis of software product lines , 2015, SPLC.

[17]  Christian Dietrich,et al.  Configuration coverage in the analysis of large-scale system software , 2011, PLOS '11.

[18]  Willard Van Orman Quine,et al.  The Problem of Simplifying Truth Functions , 1952 .

[19]  Sven Apel,et al.  A calculus for uniform feature composition , 2010, TOPL.

[20]  Dirk Beyer,et al.  CPAchecker: A Tool for Configurable Software Verification , 2009, CAV.

[21]  Pierre-Yves Schobbens,et al.  Symbolic model checking of software product lines , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[22]  Martin D. Davis,et al.  Computability and Unsolvability , 1959, McGraw-Hill Series in Information Processing and Computers.

[23]  Gunter Saake,et al.  A Classification and Survey of Analysis Strategies for Software Product Lines , 2014, ACM Comput. Surv..

[24]  Sven Apel,et al.  Generating Qualifiable Avionics Software : An Experience Report , 2015 .

[25]  Yu Lei,et al.  In-parameter-order: a test generation strategy for pairwise testing , 1998, Proceedings Third IEEE International High-Assurance Systems Engineering Symposium (Cat. No.98EX231).

[26]  Morris Sloman,et al.  CONIC: an integrated approach to distributed computer control systems , 1983 .

[27]  Mark Carpenter,et al.  The New Statistical Analysis of Data , 2000, Technometrics.

[28]  Maurice H. ter Beek,et al.  VMC: recent advances and challenges ahead , 2014, SPLC '14.

[29]  Adnan Darwiche,et al.  On Compiling System Models for Faster and More Scalable Diagnosis , 2005, AAAI.

[30]  Jörg Liebig,et al.  Analysis and Transformation of Configurable Systems , 2015 .

[31]  Christel Baier,et al.  Principles of model checking , 2008 .

[32]  Thorsten Berger,et al.  Variability Modeling in the Real , 2012 .

[33]  Wenke Lee,et al.  CHEX: statically vetting Android apps for component hijacking vulnerabilities , 2012, CCS.

[34]  Richard C. Holt,et al.  The Linux kernel: a case study of build system variability , 2014, J. Softw. Evol. Process..

[35]  Helen J. Wang,et al.  Permission Re-Delegation: Attacks and Defenses , 2011, USENIX Security Symposium.

[36]  Sven Apel,et al.  Family-based deductive verification of software product lines , 2012, GPCE '12.

[37]  Sven Apel,et al.  Detection of feature interactions using feature-aware verification , 2011, 2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011).

[38]  Frank van der Linden,et al.  Software product lines in action , 2007 .

[39]  Paolo Liberatore,et al.  Redundancy in logic I: CNF propositional formulae , 2002, Artif. Intell..

[40]  Sven Apel,et al.  Scalable analysis of variable software , 2013, ESEC/FSE 2013.

[41]  Xinwen Zhang,et al.  Apex: extending Android permission model and enforcement with user-defined runtime constraints , 2010, ASIACCS '10.

[42]  Martin Erwig,et al.  The Choice Calculus: A Representation for Software Variation , 2011, TSEM.

[43]  Krzysztof Czarnecki,et al.  Reverse engineering feature models , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[44]  Gerard J. Holzmann,et al.  State Compression in SPIN: Recursive Indexing and Compression Training Runs , 2002 .

[45]  Jason Nieh,et al.  A measurement study of google play , 2014, SIGMETRICS '14.

[46]  Erik P. de Vink,et al.  Using mCRL2 for the analysis of software product lines , 2014, FormaliSE 2014.

[47]  Gunter Saake,et al.  Potential synergies of theorem proving and model checking for software product lines , 2014, SPLC.

[48]  Wolfgang Schröder-Preikschat,et al.  A robust approach for variability extraction from the Linux build system , 2012, SPLC '12.

[49]  Marcello D'Agostino,et al.  Tableau Methods for Classical Propositional Logic , 1999 .

[50]  Pierre-Yves Schobbens,et al.  Model checking lots of systems: efficient verification of temporal properties in software product lines , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[51]  Alastair F. Donaldson,et al.  Software Model Checking , 2014, Computing Handbook, 3rd ed..

[52]  Sebastian Oster,et al.  Automated Incremental Pairwise Testing of Software Product Lines , 2010, SPLC.

[53]  Wolfgang Schröder-Preikschat,et al.  Is The Linux Kernel a Software Product Line , 2007 .

[54]  Sven Apel,et al.  Type safety for feature-oriented product lines , 2010, Automated Software Engineering.

[55]  Maurice H. Halstead,et al.  Elements of software science (Operating and programming systems series) , 1977 .

[56]  Tatjana Kapus,et al.  Specifying system families with TLA , 2012, ICSE 2012.

[57]  Pierre Marquis,et al.  A Knowledge Compilation Map , 2002, J. Artif. Intell. Res..

[58]  Mira Mezini,et al.  SPLLIFT: statically analyzing software product lines in minutes instead of years , 2013, Software Engineering.

[59]  Hareton K. N. Leung,et al.  A survey of combinatorial testing , 2011, CSUR.

[60]  Randal E. Bryant,et al.  Symbolic Boolean manipulation with ordered binary-decision diagrams , 1992, CSUR.

[61]  Roberto Erick Lopez-Herrejon,et al.  A Standard Problem for Evaluating Product-Line Methodologies , 2001, GCSE.

[62]  Sven Apel,et al.  Feature scattering in the large: a longitudinal study of Linux kernel device drivers , 2015, MODULARITY.

[63]  Philippe Oechslin,et al.  Making a Faster Cryptanalytic Time-Memory Trade-Off , 2003, CRYPTO.

[64]  Yuanyuan Zhang,et al.  The App Sampling Problem for App Store Mining , 2015, 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories.

[65]  Andreas Classen Modelling and Model Checking Variability-Intensive Systems , 2011 .

[66]  Sven Apel,et al.  Strategies for product-line verification: Case studies and experiments , 2013, 2013 35th International Conference on Software Engineering (ICSE).

[67]  Bruce McMillin,et al.  Software engineering: What is it? , 2018, 2018 IEEE Aerospace Conference.

[68]  Igor L. Markov,et al.  FORCE: a fast and easy-to-implement variable-ordering heuristic , 2003, GLSVLSI '03.

[69]  Sarfraz Khurshid,et al.  Shared Execution for Efficiently Testing Product Lines , 2012, 2012 IEEE 23rd International Symposium on Software Reliability Engineering.

[70]  Frank Dordowsky,et al.  Adopting software product line principles to manage software variants in a complex avionics system , 2009, SPLC.

[71]  Lujo Bauer,et al.  Android taint flow analysis for app sets , 2014, SOAP '14.

[72]  Kathi Fisler,et al.  Modular Verification of Open Features Using Three-Valued Model Checking , 2005, Automated Software Engineering.

[73]  Gunter Saake,et al.  Predicting performance via automated feature-interaction detection , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[74]  Frank Dordowsky,et al.  Implementing a Software Product Line for a Complex Avionics System , 2011, 2011 15th International Software Product Line Conference.

[75]  Kathi Fisler,et al.  Interfaces for modular feature verification , 2002, Proceedings 17th IEEE International Conference on Automated Software Engineering,.

[76]  Sven Apel,et al.  Facilitating Reuse in Multi-goal Test-Suite Generation for Software Product Lines , 2015, FASE.

[77]  Robert J. Hall,et al.  Fundamental Nonmodularity in Electronic Mail , 2004, Automated Software Engineering.

[78]  Sankardas Roy,et al.  Amandroid: A Precise and General Inter-component Data Flow Analysis Framework for Security Vetting of Android Apps , 2014, CCS.

[79]  Stefania Gnesi,et al.  A behavioural model for product families , 2007, ESEC-FSE '07.

[80]  Sven Apel,et al.  Analyzing the discipline of preprocessor annotations in 30 million lines of C code , 2011, AOSD '11.

[81]  Thomas W. Reps,et al.  Precise interprocedural dataflow analysis via graph reachability , 1995, POPL '95.

[82]  Olivier Coudert,et al.  Implicit and incremental computation of primes and essential primes of Boolean functions , 1992, [1992] Proceedings 29th ACM/IEEE Design Automation Conference.

[83]  Sven Apel,et al.  Refactoring Feature Modules , 2009, ICSR.

[84]  Glenford J. Myers,et al.  Art of Software Testing , 1979 .

[85]  Jing Liu,et al.  Compositional model checking of software product lines using variation point obligations , 2010, Automated Software Engineering.

[86]  Maurice H. ter Beek,et al.  A Logical Framework to Deal with Variability , 2010, IFM.

[87]  Myra B. Cohen,et al.  Improving the Testing and Testability of Software Product Lines , 2010, SPLC.

[88]  Rocco De Nicola,et al.  Action versus State based Logics for Transition Systems , 1990, Semantics of Systems of Concurrent Processes.

[89]  Sabrina Hirsch,et al.  Logic Minimization Algorithms For Vlsi Synthesis , 2016 .

[90]  Pierre-Yves Schobbens,et al.  Featured Transition Systems: Foundations for Verifying Variability-Intensive Systems and Their Application to LTL Model Checking , 2013, IEEE Transactions on Software Engineering.

[91]  Donald D. Cowan,et al.  Efficient compilation techniques for large scale feature models , 2008, GPCE '08.

[92]  Thorsten Berger,et al.  Static Analysis of App Dependencies in Android Bytecode-Technical , 2015 .

[93]  Kyo Chul Kang,et al.  Feature-Oriented Domain Analysis (FODA) Feasibility Study , 1990 .

[94]  Patrick Heymans Formal methods for the masses , 2012, SPLC '12.

[95]  Krzysztof Czarnecki,et al.  Variability mechanisms in software ecosystems , 2014, Inf. Softw. Technol..

[96]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools (2nd Edition) , 2006 .

[97]  Pierre-Yves Schobbens,et al.  Simulation-based abstractions for software product-line model checking , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[98]  Sven Apel,et al.  A model of refactoring physically and virtually separated features , 2009, GPCE '09.

[99]  William R. Cook,et al.  Fitting the pieces together: a machine-checked model of safe composition , 2009, ESEC/FSE '09.

[100]  Swarat Chaudhuri,et al.  A Study of Android Application Security , 2011, USENIX Security Symposium.

[101]  Martin Erwig,et al.  An error-tolerant type system for variational lambda calculus , 2012, ICFP.

[102]  Jun Gu,et al.  Algorithms for the satisfiability (SAT) problem: A survey , 1996, Satisfiability Problem: Theory and Applications.

[103]  Alma L. Juarez Dominguez,et al.  Detection of Feature Interactions in Automotive Active Safety Features , 2012 .

[104]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[105]  Alexander M. Gruler,et al.  A formal approach to software product families , 2010 .

[106]  Derek Coleman,et al.  A cooperative model for cross-divisional product development for a software product line , 2000, SPLC.

[107]  M. Acher Managing, multiple feature models : foundations, languages and applications , 2011 .

[108]  Brian Randell,et al.  Software engineering : report on a conference sponsored by the NATO Science Committee, Garmisch, Germany, 7th to 11th October 1968 , 1969 .

[109]  Helmut Veith,et al.  Information Reuse for Multi-goal Reachability Analyses , 2013, ESOP.

[110]  Paul Barry,et al.  Programming Perl 3rd Edition , 2000 .

[111]  Sathiamoorthy Subbarayan,et al.  Integrating CSP Decomposition Techniques and BDDs for Compiling Configuration Problems , 2005, CPAIOR.

[112]  Marcilio Mendonça,et al.  Efficient Reasoning Techniques for Large Scale Feature Models , 2009 .

[113]  Reiner Hähnle,et al.  Formal Methods in Software Product Line Engineering , 2011, Computer.

[114]  Wolfgang Schröder-Preikschat,et al.  Static Analysis of Variability in System Software: The 90, 000 #ifdefs Issue , 2014, USENIX Annual Technical Conference.

[115]  Sebastian Erdweg,et al.  A variability-aware module system , 2012, OOPSLA '12.

[116]  Sebastián Uchitel,et al.  A foundation for behavioural conformance in software product line architectures , 2006, ROSATEA '06.

[117]  Ina Schaefer,et al.  Compositional type checking of delta-oriented software product lines , 2012, Acta Informatica.

[118]  Yajin Zhou,et al.  Dissecting Android Malware: Characterization and Evolution , 2012, 2012 IEEE Symposium on Security and Privacy.

[119]  Pierre-Yves Schobbens,et al.  Counterexample guided abstraction refinement of product-line behavioural models , 2014, Software Engineering.

[120]  Mark Ryan,et al.  Plug-and-play Features , 1998, FIW.

[121]  Sven Apel,et al.  An analysis of the variability in forty preprocessor-based software product lines , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[122]  Olivier Coudert,et al.  Verification of Synchronous Sequential Machines Based on Symbolic Execution , 1989, Automatic Verification Methods for Finite State Systems.

[123]  Marinella Petrocchi,et al.  Towards an executable algebra for product lines , 2012, SPLC '12.

[124]  Klaus Pohl,et al.  Model Checking of Domain Artifacts in Product Line Engineering , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[125]  Jens Vygen,et al.  The Book Review Column1 , 2020, SIGACT News.

[126]  Reinhard Tartler,et al.  Mastering Variability Challenges in Linux and Related Highly-Configurable System Software , 2013 .

[127]  Sven Apel,et al.  Presence-Condition Simplification in Highly Configurable Systems , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[128]  Michael Franz,et al.  Dynamic taint propagation for Java , 2005, 21st Annual Computer Security Applications Conference (ACSAC'05).

[129]  Martin Erwig,et al.  Extending Type Inference to Variational Programs , 2014, ACM Trans. Program. Lang. Syst..

[130]  H. Andersen An Introduction to Binary Decision Diagrams , 1997 .

[131]  Steve Hanna,et al.  Android permissions demystified , 2011, CCS '11.

[132]  Thomas Leich,et al.  RobbyDBMS: a case study on hardware/software product line engineering , 2009, FOSD '09.

[133]  Donald D. Cowan,et al.  S.P.L.O.T.: software product lines online tools , 2009, OOPSLA Companion.

[134]  Krzysztof Czarnecki,et al.  A Study of Variability Models and Languages in the Systems Software Domain , 2013, IEEE Transactions on Software Engineering.

[135]  E. McCluskey Minimization of Boolean functions , 1956 .

[136]  Jacques Klein,et al.  Automated and Scalable T-wise Test Case Generation Strategies for Software Product Lines , 2010, 2010 Third International Conference on Software Testing, Verification and Validation.

[137]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[138]  Muffy Calder,et al.  Feature interaction detection by pairwise analysis of LTL properties—A case study , 2006, Formal Methods Syst. Des..

[139]  Sven Apel,et al.  The PLA model: on the combination of product-line analyses , 2013, VaMoS '13.

[140]  R. K. Shyamasundar,et al.  Introduction to algorithms , 1996 .

[141]  Gunter Saake,et al.  Feature-Oriented Software Product Lines , 2013, Springer Berlin Heidelberg.

[142]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[143]  Randal E. Bryant,et al.  Efficient implementation of a BDD package , 1991, DAC '90.

[144]  Sven Apel,et al.  Scalable Prediction of Non-functional Properties in Software Product Lines , 2011, 2011 15th International Software Product Line Conference.

[145]  Helmut Veith,et al.  Counterexample-guided abstraction refinement for symbolic model checking , 2003, JACM.

[146]  Vivek Sarkar,et al.  Automatic detection of inter-application permission leaks in Android applications , 2013, IBM J. Res. Dev..

[147]  Sven Apel,et al.  FEATUREHOUSE: Language-independent, automated software composition , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[148]  Jon Whittle,et al.  Model composition in product lines and feature interaction detection using critical pair analysis , 2007, MODELS'07.

[149]  Thierry Jéron,et al.  On-the-fly verification of finite transition systems , 1992, Formal Methods Syst. Des..

[150]  Sven Apel,et al.  Morpheus: Variability-Aware Refactoring in the Wild , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[151]  Don S. Batory,et al.  Feature-oriented programming and the AHEAD tool suite , 2004, Proceedings. 26th International Conference on Software Engineering.

[152]  Sven Apel,et al.  Family-based performance measurement , 2014 .

[153]  David A. Wagner,et al.  Analyzing inter-application communication in Android , 2011, MobiSys '11.

[154]  Byung-Gon Chun,et al.  TaintDroid: An Information-Flow Tracking System for Realtime Privacy Monitoring on Smartphones , 2010, OSDI.

[155]  Sven Apel,et al.  Lifting inter-app data-flow analysis to large app sets , 2017, Automated Software Engineering.

[156]  Sven Apel,et al.  An algebraic foundation for automatic feature-based program synthesis , 2010, Sci. Comput. Program..

[157]  O. Coudert,et al.  Two-level logic minimization , 2001 .

[158]  Maurice H. ter Beek,et al.  Challenges in Modelling and Analyzing Quantitative Aspects of Bike-Sharing Systems , 2014, ISoLA.

[159]  Klaus Havelund,et al.  Model checking programs , 2000, Proceedings ASE 2000. Fifteenth IEEE International Conference on Automated Software Engineering.

[160]  Sven Apel,et al.  Superimposition: A Language-Independent Approach to Software Composition , 2008, SC@ETAPS.

[161]  Sven Apel,et al.  Granularity in software product lines , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[162]  Gunter Saake,et al.  Type checking annotation-based product lines , 2012, TSEM.

[163]  Edith Hemaspaandra,et al.  Minimization for Generalized Boolean Formulas , 2011, IJCAI.

[164]  Thomas Leich,et al.  Do background colors improve program comprehension in the #ifdef hell? , 2012, Empirical Software Engineering.

[165]  Maurice H. ter Beek,et al.  A Model-Checking Tool for Families of Services , 2011, FMOODS/FORTE.

[166]  Myra B. Cohen,et al.  Interaction testing of highly-configurable systems in the presence of constraints , 2007, ISSTA '07.

[167]  Krzysztof Czarnecki,et al.  SAT-based analysis of feature models is easy , 2009, SPLC.

[168]  Norman Hardy,et al.  The Confused Deputy: (or why capabilities might have been invented) , 1988, OPSR.

[169]  Mario Kolberg,et al.  Results of the Second Feature Interaction Contest , 2000, FIW.

[170]  Danilo Beuche,et al.  Managing Flexibility: Modeling Binding-Times in Simulink , 2009, ECMDA-FA.

[171]  Ahmed E. Hassan,et al.  A Large-Scale Empirical Study on Software Reuse in Mobile Apps , 2014, IEEE Software.

[172]  Robin Milner,et al.  Communicating and mobile systems - the Pi-calculus , 1999 .

[173]  William Snavely,et al.  Making DidFail Succeed: Enhancing the CERT Static Taint Analyzer for Android App Sets , 2015 .

[174]  Malte LochauSebastian Model-based pairwise testing for feature interaction coverage in software product line engineering , 2012 .

[175]  Sven Apel,et al.  Toward variability-aware testing , 2012, FOSD '12.

[176]  Sven Apel,et al.  How AspectJ is Used: An Analysis of Eleven AspectJ Programs , 2010, J. Object Technol..

[177]  Edmund M. Clarke,et al.  Model Checking and the State Explosion Problem , 2011, LASER Summer School.

[178]  Malte Lochau,et al.  Model-Based Conformance Testing of Software Product Lines , 2012 .

[179]  Michel Sintzoff,et al.  Formal derivation of strongly correct concurrent programs , 2004, Acta Informatica.

[180]  Jacques Klein,et al.  Pairwise testing for software product lines: comparison of two approaches , 2012, Software Quality Journal.

[181]  Eric Bodden,et al.  SuSi: A Tool for the Fully Automated Classification and Categorization of Android Sources and Sinks , 2013 .

[182]  Robert Love,et al.  Linux Kernel Development (2nd Edition) (Novell Press) , 2005 .

[183]  Daniel Kroening,et al.  Automating Software Analysis at Large Scale , 2014, MEMICS.

[184]  Sven Apel,et al.  A comparison of product-based, feature-based, and family-based type checking , 2013, GPCE '13.

[185]  Axel van Lamsweerde,et al.  Generating Process Models in Multi-View Environments , 2015, Dependable Software Systems Engineering.