A product line is often developed in the context of a set of related product lines. When supporting separate feature development, we might have product populations, with product line versions being simultaneously developed in different branches. Multi product lines involve a number of product lines that depend on each other. A product line refinement notion formalizes safe evolution, but this is not sufficient for reasoning over sets of product lines. We propose refinement notions and compositionality properties that help to explain how we can support modular development in these contexts. Thus, we formally define the foundations for safe and modular evolution of product populations and multi product lines, enabling developers to perform changes in a systematic manner.
{"title":"Safe evolution of product populations and multi product lines","authors":"Leopoldo Teixeira, Paulo Borba, Rohit Gheyi","doi":"10.1145/2791060.2791084","DOIUrl":"https://doi.org/10.1145/2791060.2791084","url":null,"abstract":"A product line is often developed in the context of a set of related product lines. When supporting separate feature development, we might have product populations, with product line versions being simultaneously developed in different branches. Multi product lines involve a number of product lines that depend on each other. A product line refinement notion formalizes safe evolution, but this is not sufficient for reasoning over sets of product lines. We propose refinement notions and compositionality properties that help to explain how we can support modular development in these contexts. Thus, we formally define the foundations for safe and modular evolution of product populations and multi product lines, enabling developers to perform changes in a systematic manner.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"8 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124047009","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
J. B. P. Filho, Simon Allier, Olivier Barais, M. Acher, B. Baudry
Product Derivation is a key activity in Software Product Line Engineering. During this process, derivation operators modify or create core assets (e.g., model elements, source code instructions, components) by adding, removing or substituting them according to a given configuration. The result is a derived product that generally needs to conform to a programming or modeling language. Some operators lead to invalid products when applied to certain assets, some others do not; knowing this in advance can help to better use them, however this is challenging, specially if we consider assets expressed in extensive and complex languages such as Java. In this paper, we empirically answer the following question: which product line operators, applied to which program elements, can synthesize variants of programs that are incorrect, correct or perhaps even conforming to test suites? We implement source code transformations, based on the derivation operators of the Common Variability Language. We automatically synthesize more than 370,000 program variants from a set of 8 real large Java projects (up to 85,000 lines of code), obtaining an extensive panorama of the sanity of the operations.
{"title":"Assessing product line derivation operators applied to Java source code: an empirical study","authors":"J. B. P. Filho, Simon Allier, Olivier Barais, M. Acher, B. Baudry","doi":"10.1145/2791060.2791099","DOIUrl":"https://doi.org/10.1145/2791060.2791099","url":null,"abstract":"Product Derivation is a key activity in Software Product Line Engineering. During this process, derivation operators modify or create core assets (e.g., model elements, source code instructions, components) by adding, removing or substituting them according to a given configuration. The result is a derived product that generally needs to conform to a programming or modeling language. Some operators lead to invalid products when applied to certain assets, some others do not; knowing this in advance can help to better use them, however this is challenging, specially if we consider assets expressed in extensive and complex languages such as Java. In this paper, we empirically answer the following question: which product line operators, applied to which program elements, can synthesize variants of programs that are incorrect, correct or perhaps even conforming to test suites? We implement source code transformations, based on the derivation operators of the Common Variability Language. We automatically synthesize more than 370,000 program variants from a set of 8 real large Java projects (up to 85,000 lines of code), obtaining an extensive panorama of the sanity of the operations.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"49 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121892589","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Jabier Martinez, T. Ziadi, Tegawendé F. Bissyandé, Jacques Klein, Yves Le Traon
Although Software Product Lines are recurrently praised as an efficient paradigm for systematic reuse, practical adoption remains challenging. For bottom-up Software Product Line adoption, where a set of artefact variants already exists, practitioners lack end-to-end support for chaining (1) feature identification, (2) feature location, (3) feature constraints discovery, as well as (4) reengineering approaches. This challenge can be overcome if there exists a set of principles for building a framework to integrate various algorithms and to support different artefact types. In this paper, we propose the principles of such a framework and we provide insights on how it can be extended with adapters, algorithms and visualisations enabling their use in different scenarios. We describe its realization in BUT4Reuse (Bottom--Up Technologies for Reuse) and we assess its generic and extensible properties by implementing a variety of extensions. We further empirically assess the complexity of integration by reproducing case studies from the literature. Finally, we present an experiment where users realize a bottom-up Software Product Line adoption building on the case study of Eclipse variants.
{"title":"Bottom-up adoption of software product lines: a generic and extensible approach","authors":"Jabier Martinez, T. Ziadi, Tegawendé F. Bissyandé, Jacques Klein, Yves Le Traon","doi":"10.1145/2791060.2791086","DOIUrl":"https://doi.org/10.1145/2791060.2791086","url":null,"abstract":"Although Software Product Lines are recurrently praised as an efficient paradigm for systematic reuse, practical adoption remains challenging. For bottom-up Software Product Line adoption, where a set of artefact variants already exists, practitioners lack end-to-end support for chaining (1) feature identification, (2) feature location, (3) feature constraints discovery, as well as (4) reengineering approaches. This challenge can be overcome if there exists a set of principles for building a framework to integrate various algorithms and to support different artefact types. In this paper, we propose the principles of such a framework and we provide insights on how it can be extended with adapters, algorithms and visualisations enabling their use in different scenarios. We describe its realization in BUT4Reuse (Bottom--Up Technologies for Reuse) and we assess its generic and extensible properties by implementing a variety of extensions. We further empirically assess the complexity of integration by reproducing case studies from the literature. Finally, we present an experiment where users realize a bottom-up Software Product Line adoption building on the case study of Eclipse variants.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"59 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129418710","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Jaime Font, Manuel Ballarín, Øystein Haugen, Carlos Cetina
The aim of domain engineering process is to define and realise the commonality and variability of a Software Product Line. In the context of a family of models, spotting the commonalities and differences may become cumbersome and error prone as the number of models and its complexity increases. This work presents an approach to automate the formalization of variability in a given family of models. As output, the variability is made explicit in terms of Common Variability Language. The model commonalities and differences are specified as placements over a base model and replacements in a model library. The resulting Software Product Line (SPL) enables the derivation of new product models by reusing the extracted model fragments. Furthermore, the SPL can be evolved by the creation of new models, which are in turn automatically decomposed as model fragments of the SPL. The approach has been validated with our industrial partner (BSH), an induction hobs company. Finally, we present five different evolution scenarios encountered during the validation.
{"title":"Automating the variability formalization of a model family by means of common variability language","authors":"Jaime Font, Manuel Ballarín, Øystein Haugen, Carlos Cetina","doi":"10.1145/2791060.2793678","DOIUrl":"https://doi.org/10.1145/2791060.2793678","url":null,"abstract":"The aim of domain engineering process is to define and realise the commonality and variability of a Software Product Line. In the context of a family of models, spotting the commonalities and differences may become cumbersome and error prone as the number of models and its complexity increases. This work presents an approach to automate the formalization of variability in a given family of models. As output, the variability is made explicit in terms of Common Variability Language. The model commonalities and differences are specified as placements over a base model and replacements in a model library. The resulting Software Product Line (SPL) enables the derivation of new product models by reusing the extracted model fragments. Furthermore, the SPL can be evolved by the creation of new models, which are in turn automatically decomposed as model fragments of the SPL. The approach has been validated with our industrial partner (BSH), an induction hobs company. Finally, we present five different evolution scenarios encountered during the validation.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"35 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128890917","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Aleksandar S. Dimovski, Ahmad Salim Al-Sibahi, Claus Brabrand, A. Wąsowski
Model checking provides a convenient way to check whether a given software system is correct with respect to a set of relevant semantic properties. To use a model checker like SPIN [5], the software system must be modelled as a transition system (TS). Afterwards, the model checker can check the correctness of the translated TS by exhaustively exploring all possible transitions. For families of software systems Classen et al. [1] present a lifted model checker SNIP, where each family is modelled as a Featured TS [2] that has transitions guarded by feature expressions. SNIP is highly specialized and uses heuristics to avoid naïvely iterating through all possible variations; however, the number of configurations is still exponential in size and thus the model checker can only feasibly handle systems of a limited size. We adapt our previous work on applying variability abstraction to lifted data-flow analysis [3] to the setting of lifted model checking. We present a calculus of variability abstractions that trade precision for speed while preserving correctness [4]. The abstractions work symbiotically with the lifted model checker SNIP, but can also work with the classical and efficient off-the-shelf model checker SPIN without requiring any knowledge of variability. We prove semantically how each abstraction operation in the calculus forms a Galois collection, and therefore is suitable to use in abstract interpretation of Featured TS. Furthermore, we present an equivalent lightweight syntactic transformation tool that works directly on the input text files and does not require explicitly constructing the corresponding Featured TS in memory. Our results show that there are orders of magnitudes to be gained in performance compared to performing lifted analysis alone; we show how our tool scales better than the existing tools and makes analysing some previously infeasible models feasible. Furthermore, we also show that many models could be verified swiftly using the abstracted analysis without requiring all of the precision that a concrete analysis provides.
{"title":"Family-based model checking using off-the-shelf model checkers: extended abstract","authors":"Aleksandar S. Dimovski, Ahmad Salim Al-Sibahi, Claus Brabrand, A. Wąsowski","doi":"10.1145/2791060.2791119","DOIUrl":"https://doi.org/10.1145/2791060.2791119","url":null,"abstract":"Model checking provides a convenient way to check whether a given software system is correct with respect to a set of relevant semantic properties. To use a model checker like SPIN [5], the software system must be modelled as a transition system (TS). Afterwards, the model checker can check the correctness of the translated TS by exhaustively exploring all possible transitions. For families of software systems Classen et al. [1] present a lifted model checker SNIP, where each family is modelled as a Featured TS [2] that has transitions guarded by feature expressions. SNIP is highly specialized and uses heuristics to avoid naïvely iterating through all possible variations; however, the number of configurations is still exponential in size and thus the model checker can only feasibly handle systems of a limited size. We adapt our previous work on applying variability abstraction to lifted data-flow analysis [3] to the setting of lifted model checking. We present a calculus of variability abstractions that trade precision for speed while preserving correctness [4]. The abstractions work symbiotically with the lifted model checker SNIP, but can also work with the classical and efficient off-the-shelf model checker SPIN without requiring any knowledge of variability. We prove semantically how each abstraction operation in the calculus forms a Galois collection, and therefore is suitable to use in abstract interpretation of Featured TS. Furthermore, we present an equivalent lightweight syntactic transformation tool that works directly on the input text files and does not require explicitly constructing the corresponding Featured TS in memory. Our results show that there are orders of magnitudes to be gained in performance compared to performing lifted analysis alone; we show how our tool scales better than the existing tools and makes analysing some previously infeasible models feasible. Furthermore, we also show that many models could be verified swiftly using the abstracted analysis without requiring all of the precision that a concrete analysis provides.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"55 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126151463","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
In this paper, we sketch how treating product lines as systems of possibly heterogeneous constraints allows one to elegantly and consistently manage product lines in terms of a product line of product lines. In fact, as will also be illustrated along our example scenarios, this leads to a framework for a consistent division of labour in an "easy for the many difficult for the few" fashion which supports correctness by construction. Central for this approach are our powerful model-based synthesis and code generation technologies, which turn systems of constraints into executable models or target code.
{"title":"User-level synthesis: treating product lines as systems of constraints","authors":"B. Steffen, Anna-Lena Lamprecht, T. Margaria","doi":"10.1145/2791060.2793675","DOIUrl":"https://doi.org/10.1145/2791060.2793675","url":null,"abstract":"In this paper, we sketch how treating product lines as systems of possibly heterogeneous constraints allows one to elegantly and consistently manage product lines in terms of a product line of product lines. In fact, as will also be illustrated along our example scenarios, this leads to a framework for a consistent division of labour in an \"easy for the many difficult for the few\" fashion which supports correctness by construction. Central for this approach are our powerful model-based synthesis and code generation technologies, which turn systems of constraints into executable models or target code.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"22 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128106160","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The composition of features that interact with each other is challenging. Algebraic formalisms have been proposed by various authors to describe feature compositions and their interactions. The intention of feature compositions is the composition of fragments of documents of any kind to a product that fulfills users' requirements expressed by a feature selection. These modules often include code modules of typed programming languages whereas the proposed algebraic formalism is agnostic to types. This situation can lead to product code which is not type correct. In addition, types can carry semantic information on a program or module. We present a type system and connect it to an algebraic formalism thereby allowing automatic synthesis of feature compositions yielding well-typed programs.
{"title":"Synthesizing type-safe compositions in feature oriented software designs using staged composition","authors":"Boris Düdder, J. Rehof, G. Heineman","doi":"10.1145/2791060.2793677","DOIUrl":"https://doi.org/10.1145/2791060.2793677","url":null,"abstract":"The composition of features that interact with each other is challenging. Algebraic formalisms have been proposed by various authors to describe feature compositions and their interactions. The intention of feature compositions is the composition of fragments of documents of any kind to a product that fulfills users' requirements expressed by a feature selection. These modules often include code modules of typed programming languages whereas the proposed algebraic formalism is agnostic to types. This situation can lead to product code which is not type correct. In addition, types can carry semantic information on a program or module. We present a type system and connect it to an algebraic formalism thereby allowing automatic synthesis of feature compositions yielding well-typed programs.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"2 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128487348","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Managing product variants and versions in an integrated way, e.g. to cope with the inherent complexity of product or solution portfolios, to reduce time to market, or to provide a coherent user experience to end users, is an ever increasing engineering challenge and competition factor in all business segments. Various engineering approaches including cloning, product or component platforms, product lines, production lines, and configurable systems are followed in practice to cope with the product variation in space and time. Unfortunately, there is no silver-bullet approach, and companies have to choose and adopt respective approaches in a deliberate way, but there is often only limited understanding of how to do so. Adoption problems, unexploited potential, wasted investments, frustration and disapproval are typical symptoms, which can be seen in consequence in the wild.
{"title":"Lean variation management: increasing business value with a diversified approach","authors":"Martin Becker, Bo Zhang","doi":"10.1145/2791060.2791098","DOIUrl":"https://doi.org/10.1145/2791060.2791098","url":null,"abstract":"Managing product variants and versions in an integrated way, e.g. to cope with the inherent complexity of product or solution portfolios, to reduce time to market, or to provide a coherent user experience to end users, is an ever increasing engineering challenge and competition factor in all business segments. Various engineering approaches including cloning, product or component platforms, product lines, production lines, and configurable systems are followed in practice to cope with the product variation in space and time. Unfortunately, there is no silver-bullet approach, and companies have to choose and adopt respective approaches in a deliberate way, but there is often only limited understanding of how to do so. Adoption problems, unexploited potential, wasted investments, frustration and disapproval are typical symptoms, which can be seen in consequence in the wild.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"12 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133936633","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Thomas Degueule, J. B. P. Filho, Olivier Barais, M. Acher, J. Noir, Sébastien Madelénat, G. Gailliard, Godefroy Burlot, Olivier Constant
In systems engineering, the deployment of software components is error-prone since numerous safety and security rules have to be preserved. Furthermore, many deployments on different heterogeneous platforms are possible. In this paper we present a technological solution to assist industrial practitioners in producing a safe and secure solution out of numerous architectural variants. First, we introduce a pattern technology that provides correct-by-construction deployment models through the reuse of modeling artifacts organized in a catalog. Second, we develop a variability solution, connected to the pattern technology and based on an extension of the common variability language, for supporting the synthesis of model-based architectural variants. This paper describes a live demonstration of an industrial effort seeking to bridge the gap between variability modeling and model-based systems engineering practices. We illustrate the tooling support with an industrial case study (a secure radio platform).
{"title":"Tooling support for variability and architectural patterns in systems engineering","authors":"Thomas Degueule, J. B. P. Filho, Olivier Barais, M. Acher, J. Noir, Sébastien Madelénat, G. Gailliard, Godefroy Burlot, Olivier Constant","doi":"10.1145/2791060.2791097","DOIUrl":"https://doi.org/10.1145/2791060.2791097","url":null,"abstract":"In systems engineering, the deployment of software components is error-prone since numerous safety and security rules have to be preserved. Furthermore, many deployments on different heterogeneous platforms are possible. In this paper we present a technological solution to assist industrial practitioners in producing a safe and secure solution out of numerous architectural variants. First, we introduce a pattern technology that provides correct-by-construction deployment models through the reuse of modeling artifacts organized in a catalog. Second, we develop a variability solution, connected to the pattern technology and based on an extension of the common variability language, for supporting the synthesis of model-based architectural variants. This paper describes a live demonstration of an industrial effort seeking to bridge the gap between variability modeling and model-based systems engineering practices. We illustrate the tooling support with an industrial case study (a secure radio platform).","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123678005","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Miao Fang, G. Leyh, Jörg Dörr, Christoph Elsner, Jingjing Zhao
Many systems in the industrial automation domain include information systems. They manage manufacturing processes and control numerous distributed hardware and software components. In current practice, the development and reuse of such systems is costly and time-consuming, due to the variability of systems' topology and processes. Up to now, product line approaches for systematic modeling and management of variability have not been well established for such complex domains. In this paper, we present a model-based approach to support the derivation of systems in the target domain. The proposed architecture of the derivation infrastructure enables feature-, topology- and process configuration to be integrated into the multi-staged derivation process. We have developed a prototype to prove feasibility and improvement of derivation efficiency. We report the evaluation results that we collected through semi-structured interviews from domain stakeholders. The results show high potential to improve derivation efficiency by adopting the approach in practice. Finally, we report the lessons learned that raise the opportunities and challenges for future research.
{"title":"Towards model-based derivation of systems in the industrial automation domain","authors":"Miao Fang, G. Leyh, Jörg Dörr, Christoph Elsner, Jingjing Zhao","doi":"10.1145/2791060.2791075","DOIUrl":"https://doi.org/10.1145/2791060.2791075","url":null,"abstract":"Many systems in the industrial automation domain include information systems. They manage manufacturing processes and control numerous distributed hardware and software components. In current practice, the development and reuse of such systems is costly and time-consuming, due to the variability of systems' topology and processes. Up to now, product line approaches for systematic modeling and management of variability have not been well established for such complex domains. In this paper, we present a model-based approach to support the derivation of systems in the target domain. The proposed architecture of the derivation infrastructure enables feature-, topology- and process configuration to be integrated into the multi-staged derivation process. We have developed a prototype to prove feasibility and improvement of derivation efficiency. We report the evaluation results that we collected through semi-structured interviews from domain stakeholders. The results show high potential to improve derivation efficiency by adopting the approach in practice. Finally, we report the lessons learned that raise the opportunities and challenges for future research.","PeriodicalId":339158,"journal":{"name":"Proceedings of the 19th International Conference on Software Product Line","volume":"55 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-07-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127587239","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：