Software has eaten the world and will continue to impact society, spanning numerous application domains, including the way we're doing science and acquiring knowledge.
Software variability is key since developers, engineers, entrepreneurs, scientists can explore different hypothesis, methods, and custom products to hopefully fit a diversity of needs and usage.
In this talk, I will first illustrate the importance of software variability using different concrete examples.
I will then show that, though highly desirable, software variability also introduces an enormous complexity due to the combinatorial explosion of possible variants.
For example, 10^6000 variants of the Linux kernel may be build, much more than the estimated number of atoms in the universe (10^80).
Hence, the big picture and challenge for the audience: any organization capable of mastering software variability will have a competitive advantage.
Summer School EIT Digital.
5th July Rennes 2022
Biology, medicine, physics, astrophysics, chemistry: all these scientific domains need to process large amount of data with more and more complex software systems. For achieving reproducible science, there are several challenges ahead involving multidisciplinary collaboration and socio-technical innovation with software at the center of the problem. Despite the availability of data and code, several studies report that the same data analyzed with different software can lead to different results. I am seeing this problem as a manifestation of deep software variability: many factors (operating system, third-party libraries, versions, workloads, compile-time options and flags, etc.) themselves subject to variability can alter the results, up to the point it can dramatically change the conclusions of some scientific studies. In this keynote, I argue that deep software variability is a threat and also an opportunity for reproducible science. I first outline some works about (deep) software variability, reporting on preliminary evidence of complex interactions between variability layers. I then link the ongoing works on variability modelling and deep software variability in the quest for reproducible science.
This document discusses visualization for software analytics and identifies three key trends: 1) developers moving from solo coders to social coders, 2) software development shifting from code-centric to data-centric, and 3) visualization becoming ubiquitous rather than standalone. It provides examples of visualizations for software design, code, dynamic behavior, architecture, and human activities. It discusses how visualization can provide insights, support tasks, and communicate knowledge. It also outlines opportunities and challenges for visual analytics and ubiquitous visualization in software engineering.
The document announces an upcoming AI and OpenPOWER meetup on March 25th, 2018 in San Ramon, California from 4-7:30pm where attendees can learn about the latest advances in artificial intelligence and deep learning tools from industry leaders and pioneers and discuss how these technologies are impacting their industries. Prominent speakers will discuss topics ranging from machine learning performance and best practices to AI research at NASA and scalable machine learning with Apache SystemML on Power systems. The meetup aims to gather cutting-edge insights on AI from innovators across different sectors.
1. Revolutions in software engineering are predicted by new modes of production like software supply chains (SSCs) and suitable measurement approaches for SSCs.
2. Measurement approaches for SSCs need completeness, low cost, and high accuracy to better understand software development at scale.
3. As open source software use increases, developers must consider not just their own projects but upstream, downstream, and related projects in the large SSC network, and SSC-based measures may enable the next software engineering revolution.
Modeling and Analyzing Openness Trade-Offs in Software Platforms: A Goal-Orie...Mahsa H. Sadi
[Context and motivation] Open innovation is becoming an important strategy in software development. Following this strategy, software companies are increasingly opening up their platforms to third-party products for extension and completion. [Question / problem] Opening up software platforms to third-party applications often involves difficult trade-offs between openness requirements and critical design concerns such as security, performance, pri-vacy, and proprietary ownership. Deliberate assessment of these trade-offs is crucial to the ultimate quality and viability of an open software platform. [Principal ideas / results] We propose to treat openness as a distinct class of non-functional requirements, and to model and analyze openness requirements and related trade-offs using a goal-oriented approach. The proposed approach allows to refine and analyze openness requirements in parallel with other competing concerns in designing software platforms. The refined re-quirements are used as criteria for selecting appropriate design options. We demonstrate our approach using an example of designing an open embedded software platform for the automotive domain reported in the literature. [Contributions] The proposed approach allows to balance the fulfillment of interacting requirements in opening up platforms to third-party products, and to determine “good-enough” and “open-enough” platform design strategies.
The document announces an upcoming AI and OpenPOWER meetup event on March 25, 2018 in San Ramon, CA from 4:00 pm to 7:30 pm. Prominent speakers will discuss latest advances in deep learning tools and techniques from industry, research, and the financial sector. The meetup aims to share cutting-edge insights from pioneers in different industries.
The document announces an upcoming AI and OpenPOWER meetup on March 25th, 2018 from 4-7:30pm at 2603 Camino Ramon #200, San Ramon, CA 94583, USA. Prominent speakers will discuss advances in deep learning tools and techniques from leading innovators across industry, research, and the financial sector. Attendees will learn about AI's latest real-world impact and gather cutting-edge insights from pioneers in their industry.
Synergy of Human and Artificial Intelligence in Software EngineeringTao Xie
Keynote Talk by Tao Xie at International NSF sponsored Workshop on Realizing Artificial Intelligence Synergies in Software Engineering (RAISE 2013) http://promisedata.org/raise/2013/
Biology, medicine, physics, astrophysics, chemistry: all these scientific domains need to process large amount of data with more and more complex software systems. For achieving reproducible science, there are several challenges ahead involving multidisciplinary collaboration and socio-technical innovation with software at the center of the problem. Despite the availability of data and code, several studies report that the same data analyzed with different software can lead to different results. I am seeing this problem as a manifestation of deep software variability: many factors (operating system, third-party libraries, versions, workloads, compile-time options and flags, etc.) themselves subject to variability can alter the results, up to the point it can dramatically change the conclusions of some scientific studies. In this keynote, I argue that deep software variability is a threat and also an opportunity for reproducible science. I first outline some works about (deep) software variability, reporting on preliminary evidence of complex interactions between variability layers. I then link the ongoing works on variability modelling and deep software variability in the quest for reproducible science.
This document discusses visualization for software analytics and identifies three key trends: 1) developers moving from solo coders to social coders, 2) software development shifting from code-centric to data-centric, and 3) visualization becoming ubiquitous rather than standalone. It provides examples of visualizations for software design, code, dynamic behavior, architecture, and human activities. It discusses how visualization can provide insights, support tasks, and communicate knowledge. It also outlines opportunities and challenges for visual analytics and ubiquitous visualization in software engineering.
The document announces an upcoming AI and OpenPOWER meetup on March 25th, 2018 in San Ramon, California from 4-7:30pm where attendees can learn about the latest advances in artificial intelligence and deep learning tools from industry leaders and pioneers and discuss how these technologies are impacting their industries. Prominent speakers will discuss topics ranging from machine learning performance and best practices to AI research at NASA and scalable machine learning with Apache SystemML on Power systems. The meetup aims to gather cutting-edge insights on AI from innovators across different sectors.
1. Revolutions in software engineering are predicted by new modes of production like software supply chains (SSCs) and suitable measurement approaches for SSCs.
2. Measurement approaches for SSCs need completeness, low cost, and high accuracy to better understand software development at scale.
3. As open source software use increases, developers must consider not just their own projects but upstream, downstream, and related projects in the large SSC network, and SSC-based measures may enable the next software engineering revolution.
Modeling and Analyzing Openness Trade-Offs in Software Platforms: A Goal-Orie...Mahsa H. Sadi
[Context and motivation] Open innovation is becoming an important strategy in software development. Following this strategy, software companies are increasingly opening up their platforms to third-party products for extension and completion. [Question / problem] Opening up software platforms to third-party applications often involves difficult trade-offs between openness requirements and critical design concerns such as security, performance, pri-vacy, and proprietary ownership. Deliberate assessment of these trade-offs is crucial to the ultimate quality and viability of an open software platform. [Principal ideas / results] We propose to treat openness as a distinct class of non-functional requirements, and to model and analyze openness requirements and related trade-offs using a goal-oriented approach. The proposed approach allows to refine and analyze openness requirements in parallel with other competing concerns in designing software platforms. The refined re-quirements are used as criteria for selecting appropriate design options. We demonstrate our approach using an example of designing an open embedded software platform for the automotive domain reported in the literature. [Contributions] The proposed approach allows to balance the fulfillment of interacting requirements in opening up platforms to third-party products, and to determine “good-enough” and “open-enough” platform design strategies.
The document announces an upcoming AI and OpenPOWER meetup event on March 25, 2018 in San Ramon, CA from 4:00 pm to 7:30 pm. Prominent speakers will discuss latest advances in deep learning tools and techniques from industry, research, and the financial sector. The meetup aims to share cutting-edge insights from pioneers in different industries.
The document announces an upcoming AI and OpenPOWER meetup on March 25th, 2018 from 4-7:30pm at 2603 Camino Ramon #200, San Ramon, CA 94583, USA. Prominent speakers will discuss advances in deep learning tools and techniques from leading innovators across industry, research, and the financial sector. Attendees will learn about AI's latest real-world impact and gather cutting-edge insights from pioneers in their industry.
Synergy of Human and Artificial Intelligence in Software EngineeringTao Xie
Keynote Talk by Tao Xie at International NSF sponsored Workshop on Realizing Artificial Intelligence Synergies in Software Engineering (RAISE 2013) http://promisedata.org/raise/2013/
Analyzing Big Data's Weakest Link (hint: it might be you)HPCC Systems
Tim Menzies, NC State University, presents at the 2015 HPCC Systems Engineering Summit Community Day.
For Big Data applications, there is a lack of any gold standards for "good analysis" or methods to assess our certification programs. Hence, we are still in the dark about whether or not our human analysts are making the best use possible of the tools of Big Data. While much progress has been made in the systems aspects of Big Data, certain critical human-centered aspects remain an open issue. Regardless of the sophistication of the analysis tools and environment, all that architecture can still be used incorrectly by users. If this issue was confined to a small number of inexperienced users, then it could be addressed via process improvements such as better training. But is it? What do we know about our analysts? Where are the studies that mine the people doing the data miners?
This presentation offers some preliminary results on tools that combine ECL with other methods that recognize the code generated by experienced or inexperienced developers. While the results are preliminary, they do raise the possibility that we can better characterize what it means to be experienced (or inexperienced) at Big Data applications.
This document discusses whether big data analysis is more of a "systems" task or "human" task. It presents research showing that software defect prediction, even when conducted by top experts using the same datasets and algorithms over many years, shows little improvement and high variability. This suggests that human factors like biases are important. The document proposes using data mining on source code and social media to classify developers by expertise and identify groups who could share knowledge to reduce defects. It outlines an initial approach using parsers, classifiers like Naive Bayes to distinguish novices from experts, and seeking larger datasets from partners. The goal is to strengthen the "human" aspects of big data analysis.
The ability to recreate computational results with minimal effort and actionable metrics provides a solid foundation for scientific research and software development. When people can replicate an analysis at the touch of a button using open-source software, open data, and methods to assess and compare proposals, it significantly eases verification of results, engagement with a diverse range of contributors, and progress. However, we have yet to fully achieve this; there are still many sociotechnical frictions.
Inspired by David Donoho's vision, this talk aims to revisit the three crucial pillars of frictionless reproducibility (data sharing, code sharing, and competitive challenges) with the perspective of deep software variability.
Our observation is that multiple layers — hardware, operating systems, third-party libraries, software versions, input data, compile-time options, and parameters — are subject to variability that exacerbates frictions but is also essential for achieving robust, generalizable results and fostering innovation. I will first review the literature, providing evidence of how the complex variability interactions across these layers affect qualitative and quantitative software properties, thereby complicating the reproduction and replication of scientific studies in various fields.
I will then present some software engineering and AI techniques that can support the strategic exploration of variability spaces. These include the use of abstractions and models (e.g., feature models), sampling strategies (e.g., uniform, random), cost-effective measurements (e.g., incremental build of software configurations), and dimensionality reduction methods (e.g., transfer learning, feature selection, software debloating).
I will finally argue that deep variability is both the problem and solution of frictionless reproducibility, calling the software science community to develop new methods and tools to manage variability and foster reproducibility in software systems.
Exposé invité Journées Nationales du GDR GPL 2024
This document discusses challenges at the intersection of software engineering and artificial intelligence over the next 20 years. It proposes several challenges, including: 1) demonstrating a 20% year-over-year reduction in manual proof effort for formally verified systems; 2) developing trustable real-time AI algorithms with proofs of correctness; and 3) identifying high-impact uses of abundant cloud computing resources for SE and AI problems. It also discusses challenges around low-power systems, stress testing systems, and generating new algorithms for quantum computing.
The document provides an overview of an introduction to software engineering course. It discusses the course objectives which are to learn about difficulties in software development, different software processes, designing high-quality software, and advanced software engineering methods. The course contents are then listed, covering topics like requirements engineering, software design, testing, and project management. It also discusses the software crisis and reasons for poor project outcomes like misunderstanding software as just programming and lack of engineering practices.
Keynote VariVolution/VM4ModernTech@SPLC 2022
At compile-time or at runtime, varying software is a powerful means to achieve optimal functional and performance goals. An observation is that only considering the software layer might be naive to tune the performance of the system or test that the functionality behaves correctly. In fact, many layers (hardware, operating system, input data, build process etc.), themselves subject to variability, can alter performances of software configurations. For instance, configurations' options may have very different effects on execution time or energy consumption when used with different input data, depending on the way it has been compiled and the hardware on which it is executed.
In this talk, I will introduce the concept of “deep software variability” which refers to the interactions of all external layers modifying the behavior or non-functional properties of a software system. I will show how compile-time options, inputs, and software evolution (versions), some dimensions of deep variability, can question the generalization of the variability knowledge of popular configurable systems like Linux, gcc, xz, or x264.
I will then argue that machine learning (ML) is particularly suited to manage very large variants space. The key idea of ML is to build a model based on sample data -- here observations about software variants in variable settings -- in order to make predictions or decisions. I will review state-of-the-art solutions developed in software engineering and software product line engineering while connecting with works in ML (e.g., transfer learning, dimensionality reduction, adversarial learning). Overall, the key challenge is to leverage the right ML pipeline in order to harness all variability layers (and not only the software layer), leading to more efficient systems and variability knowledge that truly generalizes to any usage and context.
From this perspective, we are starting an initiative to collect data, software, reusable artefacts, and body of knowledge related to (deep) software variability: https://deep.variability.io
Finally, I will open a broader discussion on how machine learning and deep software variability relate to the reproducibility, replicability, and robustness of scientific, software-based studies (e.g., in neuroimaging and climate modelling).
Deepcoder to Self-Code with Machine LearningIRJET Journal
The document discusses DeepCoder, a machine learning system developed by Microsoft that is able to generate its own code by learning from existing code examples. DeepCoder is trained on a large corpus of programs and input/output examples to learn which code snippets are likely to work together to solve new problems. It can then search through code more efficiently than humans to assemble working programs from existing code blocks. While currently limited to simple 5 line programs, DeepCoder represents a significant improvement over previous program synthesis techniques and could eventually make programming accessible to non-coders. However, some media reports exaggerated DeepCoder's capabilities and inaccurately claimed it works by copying code directly from other software.
Open Source Software to Enhance the STEM Learning EnvironmentMaurice Dawson
ABSTRACT This chapter examines the use of Open Source Software (OSS) technologies that can be used to improve the learning of Science, Technology, Engineering, and Mathematics (STEM). Explored are the various methods that can be utilized to improve the percentage of STEM majors in the American educational system with resources such as: Open Source as Alternative (OSALT), virtualization, cloud computing, Linux distributions, open source programming, and open source hardware platforms. Increasing the amount of students that pursue STEM majors is important because the projected job growth in the STEM field compared to non-STEM jobs is 33%. OSALT provides cost-effective alternatives to commercial products such as Microsoft Office Suite and Adobe Photoshop. Second, creating Virtual Machines (VMs) is another avenue to teach complex concepts in computer science, engineering, and Information Technology (IT). Third, cloud computing is an inexpensive way for clients to access information from multiple locations and devices. Fourth, universities can use the Operating System (OS) Linux and its various distributions as replacements for commercial operating systems like Windows in order to reduce IT costs. Lastly, open source programming languages like Python and their associated Integrated Development Environments (IDEs) provide comprehensive facilities for software engineers for application development or testing.
Slides presented at MODEVAR 2024 co-located with VaMoS 2024: https://modevar.github.io/program/ Thanks to Jessie Galasso and Chico Sundermann for the invitation Abstract: "Variability models (e.g., feature models) are widely considered in software engineering research and practice, in order to develop software product lines, configurable systems, generators, or adaptive systems. Numerous success stories of variability models have been reported in different domains (e.g., automotive, aerospace, avionics) and the applicability broadens. However, the use of variability models is not yet universally adopted… Why? Some examples: variability models are not continuously extracted from projects and artefacts; each time a variability model is used, its expressiveness and language should be specialized; learning-based models are decoupled from variability models; modeling software variability should cover different layers and their interactions, etc. The list is arguably opinionated, incomplete, and based on my own practical experience, but also on observations of existing works. I will give 24 reasons to occupy your day as a researcher or practitioner in the field of variability modeling."
Slides: https://github.com/acherm/24RWVMANYU-VaMoS-MODEVAR/blob/main/vamos2024.md (Markdown content) PDF: https://github.com/acherm/24RWVMANYU-VaMoS-MODEVAR/blob/main/VaMoS2024-MODEVAR.pdf (slides in PDF format)
New Research Articles 2022 January Issue International Journal of Software En...ijseajournal
International Journal of Software Engineering & Applications (IJSEA)
** ERA Indexed **
ISSN: 0975 - 9018 (Online); 0976-2221 (Print)
https://airccse.org/journal/ijsea/ijsea.html
Current Issue: January 2022, Volume 13, Number 1
New Research Articles 2022 January Issue International Journal of Software Engineering & Applications (IJSEA)
Hybrid Practices in Global Software Development: A Systematic Literature Review
Rafael Camara, Iury Monte, Annelyelthon Alves and Marcelo Marinho, Federal Rural University of Pernambuco, Brazil
Study on Technical Focuses and Sampling Coverage Strategy of Airborne Software Reviews
Jinghua Sun1, Samuel Edwards2, Nic Connelly3, Andrew Bridge4 and Lei Zhang1, 1COMAC Shanghai Aircraft Design and Research Institute, China, 2Defence Aviation Safety Authority, Australia, 3RMIT University, Australia, 4European Union Aviation Safety Agency, Germany
https://airccse.org/journal/ijsea/vol13.html
Artificial intelligence (Ai) is back, and the tech industry’s interest is stronger than ever. Ai will have an important impact on the design and creation of software. Application development and delivery (AD&D) professionals need to understand the potential benefits Ai will bring, not only to how they build software but also to the nature of the applications themselves. in parallel, AD&D pros should not ignore the challenges and risks that come with Ai. this report is the first of a series that will examine the impact of Ai on software development and separate myth from reality
This document provides an overview of the Singularity project, which aims to build a new operating system and software platform from scratch with a primary goal of dependability. The Singularity system uses software-isolated processes (SIPs) that provide information hiding, failure isolation, and strong interfaces to encapsulate application and system components. SIPs differ from conventional processes by being closed object and code spaces, communicating through typed channels, and having low overhead for creation and communication. The goal of the Singularity system is to demonstrate how new programming languages, compilers, and analysis tools can enable more robust and dependable software architectures.
This document provides an overview of the Software Engineering for BS(IT) course. The course objectives are to introduce important concepts like software development models, project management, and the software development lifecycle. The course outline covers topics such as requirement engineering, software design, testing, and project management. It aims to teach students how to develop high-quality software using systematic and disciplined engineering practices.
SBQS 2013 Keynote: Cooperative Testing and AnalysisTao Xie
SBQS 2013 Keynote: Cooperative Testing and Analysis: Human-Tool, Tool-Tool, and Human-Human Cooperations to Get Work Done http://sbqs.dcc.ufba.br/view/palestrantes.php
Current software development technology almost collapses under its own complexity. Implementing the actual business-level functionality takes much more effort and time than it should be. And then requirements change.
OaaS: Objects-as-a-Service is a next-level software development model which aims to make software development as close to the domain and as flexible as the business itself.
Scalable architectures for phenotype librariesMartin Chapman
The document discusses different architectural considerations for building phenotype libraries that are accessible at a large scale. It covers software architecture, definition structure, and distribution mechanisms. For software architecture, it advocates for a microservices approach to allow components to be built with different technologies and scaled independently. For definition structure, it presents Phenoflow's model that standardizes definitions and generates computable forms. For distribution, it notes the benefits of hosting definitions in version control systems like GitHub to improve discoverability. The overall goal is to make definitions easily located, downloaded, and interpreted by many users through careful library design.
The document presents a software bug prediction model. It aims to build a resilient bug prediction model through simulation on open source issue trackers like Jira and Bugzilla. It also aims to conduct a comparative study of the new model against existing competitive models. The model will make use of data from software repositories, bug reports, and code artifacts to predict bugs. Open source projects like Eclipse, Mozilla and Android will be used for simulations. Data mining tools like WEKA and RAPID MINER will be utilized extensively. The model also aims to facilitate code refactoring to improve software maintenance activities like modification and enhancement. Literature in the areas of bug prediction and code refactoring will be surveyed. The research will be conducted in
- The document discusses the vision of developing smart modeling environments to support engineering and scientific work, with a focus on model-driven engineering.
- Key challenges include developing exploratory, literate, and live programming capabilities; multi-view, polyglot, collaborative modeling frameworks; and modeling platforms for data-centric applications.
- Example applications discussed are systems engineering and design space exploration, DevOps and digital twins, and modeling for smart cyber-physical systems and sustainability evaluation.
Intelligent Software Engineering: Synergy between AI and Software Engineering...Tao Xie
2018 Distinguished Speaker, the UC Irvine Institute for Software Research (ISR) Distinguished Speaker Series 2018-2019. "Intelligent Software Engineering: Synergy between AI and Software Engineering" http://isr.uci.edu/content/isr-distinguished-speaker-series-2018-2019
Producing a variant of code is highly challenging, particularly for individuals unfamiliar with programming. This demonstration introduces a novel use of generative AI to aid end-users in customizing code. We first describe how generative AI can be used to customize code through prompts and instructions, and further demonstrate its potential in building end-user tools for configuring code. We showcase how to transform an undocumented, technical, low-level TikZ into a user-friendly, configurable, Web-based customization tool written in Python, HTML, CSS, and JavaScript and itself configurable. We discuss how generative AI can support this transformation process and traditional variability engineering tasks, such as identification and implementation of features, synthesis of a template code generator, and development of end-user configurators. We believe it is a first step towards democratizing variability programming, opening a path for end-users to adapt code to their needs.
Programming variability is central to the design and implementation of software systems that can adapt to a variety of contexts and requirements, providing increased flexibility and customization. Managing the complexity that arises from having multiple features, variations, and possible configurations is known to be highly challenging for software developers. In this paper, we explore how large language model (LLM)-based assistants can support the programming of variability. We report on new approaches made possible with LLM-based assistants, like: features and variations can be implemented as prompts; augmentation of variability out of LLM-based domain knowledge; seamless implementation of variability in different kinds of artefacts, programming languages, and frameworks, at different binding times (compile-time or run-time). We are sharing our data (prompts, sessions, generated code, etc.) to support the assessment of the effectiveness and robustness of LLMs for variability-related tasks.
https://inria.hal.science/hal-04153310/
More Related Content
Similar to Mastering Software Variability for Innovation and Science
Analyzing Big Data's Weakest Link (hint: it might be you)HPCC Systems
Tim Menzies, NC State University, presents at the 2015 HPCC Systems Engineering Summit Community Day.
For Big Data applications, there is a lack of any gold standards for "good analysis" or methods to assess our certification programs. Hence, we are still in the dark about whether or not our human analysts are making the best use possible of the tools of Big Data. While much progress has been made in the systems aspects of Big Data, certain critical human-centered aspects remain an open issue. Regardless of the sophistication of the analysis tools and environment, all that architecture can still be used incorrectly by users. If this issue was confined to a small number of inexperienced users, then it could be addressed via process improvements such as better training. But is it? What do we know about our analysts? Where are the studies that mine the people doing the data miners?
This presentation offers some preliminary results on tools that combine ECL with other methods that recognize the code generated by experienced or inexperienced developers. While the results are preliminary, they do raise the possibility that we can better characterize what it means to be experienced (or inexperienced) at Big Data applications.
This document discusses whether big data analysis is more of a "systems" task or "human" task. It presents research showing that software defect prediction, even when conducted by top experts using the same datasets and algorithms over many years, shows little improvement and high variability. This suggests that human factors like biases are important. The document proposes using data mining on source code and social media to classify developers by expertise and identify groups who could share knowledge to reduce defects. It outlines an initial approach using parsers, classifiers like Naive Bayes to distinguish novices from experts, and seeking larger datasets from partners. The goal is to strengthen the "human" aspects of big data analysis.
The ability to recreate computational results with minimal effort and actionable metrics provides a solid foundation for scientific research and software development. When people can replicate an analysis at the touch of a button using open-source software, open data, and methods to assess and compare proposals, it significantly eases verification of results, engagement with a diverse range of contributors, and progress. However, we have yet to fully achieve this; there are still many sociotechnical frictions.
Inspired by David Donoho's vision, this talk aims to revisit the three crucial pillars of frictionless reproducibility (data sharing, code sharing, and competitive challenges) with the perspective of deep software variability.
Our observation is that multiple layers — hardware, operating systems, third-party libraries, software versions, input data, compile-time options, and parameters — are subject to variability that exacerbates frictions but is also essential for achieving robust, generalizable results and fostering innovation. I will first review the literature, providing evidence of how the complex variability interactions across these layers affect qualitative and quantitative software properties, thereby complicating the reproduction and replication of scientific studies in various fields.
I will then present some software engineering and AI techniques that can support the strategic exploration of variability spaces. These include the use of abstractions and models (e.g., feature models), sampling strategies (e.g., uniform, random), cost-effective measurements (e.g., incremental build of software configurations), and dimensionality reduction methods (e.g., transfer learning, feature selection, software debloating).
I will finally argue that deep variability is both the problem and solution of frictionless reproducibility, calling the software science community to develop new methods and tools to manage variability and foster reproducibility in software systems.
Exposé invité Journées Nationales du GDR GPL 2024
This document discusses challenges at the intersection of software engineering and artificial intelligence over the next 20 years. It proposes several challenges, including: 1) demonstrating a 20% year-over-year reduction in manual proof effort for formally verified systems; 2) developing trustable real-time AI algorithms with proofs of correctness; and 3) identifying high-impact uses of abundant cloud computing resources for SE and AI problems. It also discusses challenges around low-power systems, stress testing systems, and generating new algorithms for quantum computing.
The document provides an overview of an introduction to software engineering course. It discusses the course objectives which are to learn about difficulties in software development, different software processes, designing high-quality software, and advanced software engineering methods. The course contents are then listed, covering topics like requirements engineering, software design, testing, and project management. It also discusses the software crisis and reasons for poor project outcomes like misunderstanding software as just programming and lack of engineering practices.
Keynote VariVolution/VM4ModernTech@SPLC 2022
At compile-time or at runtime, varying software is a powerful means to achieve optimal functional and performance goals. An observation is that only considering the software layer might be naive to tune the performance of the system or test that the functionality behaves correctly. In fact, many layers (hardware, operating system, input data, build process etc.), themselves subject to variability, can alter performances of software configurations. For instance, configurations' options may have very different effects on execution time or energy consumption when used with different input data, depending on the way it has been compiled and the hardware on which it is executed.
In this talk, I will introduce the concept of “deep software variability” which refers to the interactions of all external layers modifying the behavior or non-functional properties of a software system. I will show how compile-time options, inputs, and software evolution (versions), some dimensions of deep variability, can question the generalization of the variability knowledge of popular configurable systems like Linux, gcc, xz, or x264.
I will then argue that machine learning (ML) is particularly suited to manage very large variants space. The key idea of ML is to build a model based on sample data -- here observations about software variants in variable settings -- in order to make predictions or decisions. I will review state-of-the-art solutions developed in software engineering and software product line engineering while connecting with works in ML (e.g., transfer learning, dimensionality reduction, adversarial learning). Overall, the key challenge is to leverage the right ML pipeline in order to harness all variability layers (and not only the software layer), leading to more efficient systems and variability knowledge that truly generalizes to any usage and context.
From this perspective, we are starting an initiative to collect data, software, reusable artefacts, and body of knowledge related to (deep) software variability: https://deep.variability.io
Finally, I will open a broader discussion on how machine learning and deep software variability relate to the reproducibility, replicability, and robustness of scientific, software-based studies (e.g., in neuroimaging and climate modelling).
Deepcoder to Self-Code with Machine LearningIRJET Journal
The document discusses DeepCoder, a machine learning system developed by Microsoft that is able to generate its own code by learning from existing code examples. DeepCoder is trained on a large corpus of programs and input/output examples to learn which code snippets are likely to work together to solve new problems. It can then search through code more efficiently than humans to assemble working programs from existing code blocks. While currently limited to simple 5 line programs, DeepCoder represents a significant improvement over previous program synthesis techniques and could eventually make programming accessible to non-coders. However, some media reports exaggerated DeepCoder's capabilities and inaccurately claimed it works by copying code directly from other software.
Open Source Software to Enhance the STEM Learning EnvironmentMaurice Dawson
ABSTRACT This chapter examines the use of Open Source Software (OSS) technologies that can be used to improve the learning of Science, Technology, Engineering, and Mathematics (STEM). Explored are the various methods that can be utilized to improve the percentage of STEM majors in the American educational system with resources such as: Open Source as Alternative (OSALT), virtualization, cloud computing, Linux distributions, open source programming, and open source hardware platforms. Increasing the amount of students that pursue STEM majors is important because the projected job growth in the STEM field compared to non-STEM jobs is 33%. OSALT provides cost-effective alternatives to commercial products such as Microsoft Office Suite and Adobe Photoshop. Second, creating Virtual Machines (VMs) is another avenue to teach complex concepts in computer science, engineering, and Information Technology (IT). Third, cloud computing is an inexpensive way for clients to access information from multiple locations and devices. Fourth, universities can use the Operating System (OS) Linux and its various distributions as replacements for commercial operating systems like Windows in order to reduce IT costs. Lastly, open source programming languages like Python and their associated Integrated Development Environments (IDEs) provide comprehensive facilities for software engineers for application development or testing.
Slides presented at MODEVAR 2024 co-located with VaMoS 2024: https://modevar.github.io/program/ Thanks to Jessie Galasso and Chico Sundermann for the invitation Abstract: "Variability models (e.g., feature models) are widely considered in software engineering research and practice, in order to develop software product lines, configurable systems, generators, or adaptive systems. Numerous success stories of variability models have been reported in different domains (e.g., automotive, aerospace, avionics) and the applicability broadens. However, the use of variability models is not yet universally adopted… Why? Some examples: variability models are not continuously extracted from projects and artefacts; each time a variability model is used, its expressiveness and language should be specialized; learning-based models are decoupled from variability models; modeling software variability should cover different layers and their interactions, etc. The list is arguably opinionated, incomplete, and based on my own practical experience, but also on observations of existing works. I will give 24 reasons to occupy your day as a researcher or practitioner in the field of variability modeling."
Slides: https://github.com/acherm/24RWVMANYU-VaMoS-MODEVAR/blob/main/vamos2024.md (Markdown content) PDF: https://github.com/acherm/24RWVMANYU-VaMoS-MODEVAR/blob/main/VaMoS2024-MODEVAR.pdf (slides in PDF format)
New Research Articles 2022 January Issue International Journal of Software En...ijseajournal
International Journal of Software Engineering & Applications (IJSEA)
** ERA Indexed **
ISSN: 0975 - 9018 (Online); 0976-2221 (Print)
https://airccse.org/journal/ijsea/ijsea.html
Current Issue: January 2022, Volume 13, Number 1
New Research Articles 2022 January Issue International Journal of Software Engineering & Applications (IJSEA)
Hybrid Practices in Global Software Development: A Systematic Literature Review
Rafael Camara, Iury Monte, Annelyelthon Alves and Marcelo Marinho, Federal Rural University of Pernambuco, Brazil
Study on Technical Focuses and Sampling Coverage Strategy of Airborne Software Reviews
Jinghua Sun1, Samuel Edwards2, Nic Connelly3, Andrew Bridge4 and Lei Zhang1, 1COMAC Shanghai Aircraft Design and Research Institute, China, 2Defence Aviation Safety Authority, Australia, 3RMIT University, Australia, 4European Union Aviation Safety Agency, Germany
https://airccse.org/journal/ijsea/vol13.html
Artificial intelligence (Ai) is back, and the tech industry’s interest is stronger than ever. Ai will have an important impact on the design and creation of software. Application development and delivery (AD&D) professionals need to understand the potential benefits Ai will bring, not only to how they build software but also to the nature of the applications themselves. in parallel, AD&D pros should not ignore the challenges and risks that come with Ai. this report is the first of a series that will examine the impact of Ai on software development and separate myth from reality
This document provides an overview of the Singularity project, which aims to build a new operating system and software platform from scratch with a primary goal of dependability. The Singularity system uses software-isolated processes (SIPs) that provide information hiding, failure isolation, and strong interfaces to encapsulate application and system components. SIPs differ from conventional processes by being closed object and code spaces, communicating through typed channels, and having low overhead for creation and communication. The goal of the Singularity system is to demonstrate how new programming languages, compilers, and analysis tools can enable more robust and dependable software architectures.
This document provides an overview of the Software Engineering for BS(IT) course. The course objectives are to introduce important concepts like software development models, project management, and the software development lifecycle. The course outline covers topics such as requirement engineering, software design, testing, and project management. It aims to teach students how to develop high-quality software using systematic and disciplined engineering practices.
SBQS 2013 Keynote: Cooperative Testing and AnalysisTao Xie
SBQS 2013 Keynote: Cooperative Testing and Analysis: Human-Tool, Tool-Tool, and Human-Human Cooperations to Get Work Done http://sbqs.dcc.ufba.br/view/palestrantes.php
Current software development technology almost collapses under its own complexity. Implementing the actual business-level functionality takes much more effort and time than it should be. And then requirements change.
OaaS: Objects-as-a-Service is a next-level software development model which aims to make software development as close to the domain and as flexible as the business itself.
Scalable architectures for phenotype librariesMartin Chapman
The document discusses different architectural considerations for building phenotype libraries that are accessible at a large scale. It covers software architecture, definition structure, and distribution mechanisms. For software architecture, it advocates for a microservices approach to allow components to be built with different technologies and scaled independently. For definition structure, it presents Phenoflow's model that standardizes definitions and generates computable forms. For distribution, it notes the benefits of hosting definitions in version control systems like GitHub to improve discoverability. The overall goal is to make definitions easily located, downloaded, and interpreted by many users through careful library design.
The document presents a software bug prediction model. It aims to build a resilient bug prediction model through simulation on open source issue trackers like Jira and Bugzilla. It also aims to conduct a comparative study of the new model against existing competitive models. The model will make use of data from software repositories, bug reports, and code artifacts to predict bugs. Open source projects like Eclipse, Mozilla and Android will be used for simulations. Data mining tools like WEKA and RAPID MINER will be utilized extensively. The model also aims to facilitate code refactoring to improve software maintenance activities like modification and enhancement. Literature in the areas of bug prediction and code refactoring will be surveyed. The research will be conducted in
- The document discusses the vision of developing smart modeling environments to support engineering and scientific work, with a focus on model-driven engineering.
- Key challenges include developing exploratory, literate, and live programming capabilities; multi-view, polyglot, collaborative modeling frameworks; and modeling platforms for data-centric applications.
- Example applications discussed are systems engineering and design space exploration, DevOps and digital twins, and modeling for smart cyber-physical systems and sustainability evaluation.
Intelligent Software Engineering: Synergy between AI and Software Engineering...Tao Xie
2018 Distinguished Speaker, the UC Irvine Institute for Software Research (ISR) Distinguished Speaker Series 2018-2019. "Intelligent Software Engineering: Synergy between AI and Software Engineering" http://isr.uci.edu/content/isr-distinguished-speaker-series-2018-2019
Similar to Mastering Software Variability for Innovation and Science (20)
Producing a variant of code is highly challenging, particularly for individuals unfamiliar with programming. This demonstration introduces a novel use of generative AI to aid end-users in customizing code. We first describe how generative AI can be used to customize code through prompts and instructions, and further demonstrate its potential in building end-user tools for configuring code. We showcase how to transform an undocumented, technical, low-level TikZ into a user-friendly, configurable, Web-based customization tool written in Python, HTML, CSS, and JavaScript and itself configurable. We discuss how generative AI can support this transformation process and traditional variability engineering tasks, such as identification and implementation of features, synthesis of a template code generator, and development of end-user configurators. We believe it is a first step towards democratizing variability programming, opening a path for end-users to adapt code to their needs.
Programming variability is central to the design and implementation of software systems that can adapt to a variety of contexts and requirements, providing increased flexibility and customization. Managing the complexity that arises from having multiple features, variations, and possible configurations is known to be highly challenging for software developers. In this paper, we explore how large language model (LLM)-based assistants can support the programming of variability. We report on new approaches made possible with LLM-based assistants, like: features and variations can be implemented as prompts; augmentation of variability out of LLM-based domain knowledge; seamless implementation of variability in different kinds of artefacts, programming languages, and frameworks, at different binding times (compile-time or run-time). We are sharing our data (prompts, sessions, generated code, etc.) to support the assessment of the effectiveness and robustness of LLMs for variability-related tasks.
https://inria.hal.science/hal-04153310/
The migration and reengineering of existing variants into a software product line (SPL) is an error-prone and time-consuming activity. Many extractive approaches have been proposed, spanning different activities from feature identification and naming to the synthesis of reusable artefacts. In this paper, we explore how large language model (LLM)-based assistants can support domain analysts and developers. We revisit four illustrative cases of the literature where the challenge is to migrate variants written in different formalism (UML class diagrams, Java, GraphML, statecharts). We systematically report on our experience with ChatGPT-4, describing our strategy to prompt LLMs and documenting positive aspects but also failures. We compare the use of LLMs with state-of-the-art approach, BUT4Reuse. While LLMs offer potential in assisting domain analysts and developers in transitioning software variants into SPLs, their intrinsic stochastic nature and restricted ability to manage large variants or complex structures necessitate a semiautomatic approach, complete with careful review, to counteract inaccuracies.
The document discusses deep software variability and the challenges of predicting software performance across different configuration layers. It provides an example of measuring the video encoder x264 across different hardware platforms, operating systems, compiler options, and input video files. The key points are that software performance prediction models may not generalize if they do not account for variability across these different layers. The document calls for more empirical studies of deep software variability in real-world systems to better understand how it manifests and which layers have the most influence. This knowledge could help reduce costs when exploring configuration spaces and transferring performance models between environments.
talk @ DiverSE coffee (informal, work in progress)
abstract: Cheating in chess is a serious issue, mainly due to the use of chess engines during play.
Chess engines like Stockfish or AlphaZero-like variant can give to the cheater a decisive advantage, since almost perfect moves can be played.
Already in 2006, Topalov accused Kramnik as part of the world championship.
Sébastien Feller https://en.wikipedia.org/wiki/S%C3%A9bastien_Feller case in Chess Olympiad in 2010 was a shock.
With the rise of online games and $$$, cheating is even more problematic.
A few weeks ago, Magnus Carlsen https://en.wikipedia.org/wiki/Magnus_Carlsen accused Hans Niemann (HN) of cheating over the board and refused to ever play him again.
You may have heard headlines with "anal bead" supposed to help HN.
In fact, I'm not specifically aiming to talk about chess (and cheating).
I rather want to discuss how science has been (and will be) at the heart of the anti-cheating chess problem.
I will first argue that many people (chess hobbyists/experts, data nerds, etc.), most being non-scientists, have actually done science for trying to demonstrate or refute the cheating case.
The basic idea is to confront moves played by humans (players) with those of computer engines.
With the sharing of data (analysis of chess games like those played by HN), scripts, and methods, numerous results and conclusions have emerged, getting popularized with social media (twitch, Youtube, twitter, etc.)
On the one hand, I've been quite excited to see all this energy for trying to advance our understanding and propose interesting ideas/analysis.
On the other hand, there have been some failures in the quality of some analysis or the choice of closed systems to compute unclear metrics.
In-between, there have been a report by chess.com and the analysis of the computer scientist Ken Regan https://cse.buffalo.edu/~regan/ the world renewed specialist.
I still think the problem is open (eg Regan's method is too conservative and missing many cases; chess.com methodology, though unclear and opaque at some points, is certainly effective for online cheating, but not over the board detection).
I will present a variability model of the space of experiments/methods that can be considered to address the problem.
This model can be used to pilot the collaborative effort, to reproduce, replicate or reject some experiments, and to gain confidence or robustness in some conclusions.
Another last point I want to discuss is that most probably the anti-cheating chess problem cannot be resolved solely with retrospective computational analysis.
It's just too uncertain, especially if cheaters are "smart".
(Cyber-)security experts, psychologists, chess players, and of course computer science nerds/professionals can contribute to address this multidisciplinary problem.
preprint: https://hal.inria.fr/hal-03720273
presented at SPLC 2022 research track
Linux kernels are used in a wide variety of appliances, many of them having strong requirements on the kernel size due to constraints such as limited memory or instant boot. With more than nine thousands of configuration options to choose from, developers and users of Linux actually spend significant effort to document, understand, and eventually tune (combinations of) options for meeting a kernel size. In this paper, we describe a large-scale endeavour automating this task and predicting a given Linux kernel binary size out of unmeasured configurations. We first experiment that state-of-theart solutions specifically made for configurable systems such as performance-influence models cannot cope with that number of options, suggesting that software product line techniques may need to be adapted to such huge configuration spaces. We then show that tree-based feature selection can learn a model achieving low prediction errors over a reduced set of options. The resulting model, trained on 95 854 kernel configurations, is fast to compute, simple to interpret and even outperforms the accuracy of learning without feature selection.
With large scale and complex configurable systems, it is hard for users to choose the right combination of options (i.e., configurations) in order to obtain the wanted trade-off between functionality and performance goals such as speed or size. Machine learning can help in relating these goals to the configurable system options, and thus, predict the effect of options on the outcome, typically after a costly training step. However, many configurable systems evolve at such a rapid pace that it is impractical to retrain a new model from scratch for each new version. In this paper, we propose a new method to enable transfer learning of binary size predictions among versions of the same configurable system. Taking the extreme case of the Linux kernel with its ≈ 14, 500 configuration options, we first investigate how binary size predictions of kernel size degrade over successive versions. We show that the direct reuse of an accurate prediction model from 2017 quickly becomes inaccurate when Linux evolves, up to a 32% mean error by August 2020. We thus propose a new approach for transfer evolution-aware model shifting (TEAMS). It leverages the structure of a configurable system to transfer an initial predictive model towards its future versions with a minimal amount of extra processing for each version. We show that TEAMS vastly outperforms state of the art approaches over the 3 years history of Linux kernels, from 4.13 to 5.8.
Most modern software systems are subject to variation or come in many variants. Web browsers like Firefox or Chrome are available on different operating systems, in different languages, while users can configure 2000+ preferences or install numerous 3rd parties extensions (or plugins). Web servers like Apache, operating systems like the Linux kernel, or a video encoder like x264 are other examples of software systems that are highly configurable at compile-time or at run-time for delivering the expected functionality andmeeting the various desires of users. Variability ("the ability of a software system or artifact to be efficiently extended, changed,customized or configured for use in a particular context") is therefore a crucial property of software systems. Organizations capable of mastering variability can deliver high-quality variants (or products) in a short amount of time and thus attract numerous customers, new use-cases or usage contexts. A hard problem for end-users or software developers is to master the combinatorial explosion induced by variability: Hundreds of configuration options can be combined, each potentially with distinct functionality and effects on execution time, memory footprint, quality of the result, etc. The first part of this course will introduce variability-intensive systems, their applications and challenges, in various software contexts. We will use intuitive examples (like a generator of LaTeX paper variants) and real-world systems (like the Linux kernel). A second objective of this course is to show the relevance of ArtificialIntelligence (AI) techniques for exploring and taming such enormous variability spaces. In particular, we will introduce how (1) satisfiability and constraint programming solvers can be used to properly model and reason about variability; (2) how machine learning can be used to discover constraints and predict the variability behavior of configurable systems or software product lines.
http://ejcp2019.icube.unistra.fr/
Presented at SIGCSE 2018: https://sigcse2018.sigcse.org/
Software Product Line (SPL) engineering has emerged to provide the means to efficiently model, produce, and maintain multiple similar software variants, exploiting their common properties, and managing their variabilities (differences). With over two decades of existence, the community of SPL researchers and practitioners is thriving as can be attested by the extensive research output and the numerous successful industrial projects. Education has a key role to support the next generation of practitioners to build highly complex, variability-intensive systems. Yet, it is unclear how the concepts of variability and SPLs are taught, what are the possible missing gaps and difficulties faced, what are the benefits, or what is the material available. Also, it remains unclear whether scholars teach what is actually needed by industry. In this article we report on three initiatives we have conducted with scholars, educators, industry practitioners, and students to further understand the connection between SPLs and education, i.e., an online survey on teaching SPLs we performed with 35 scholars, another survey on learning SPLs we conducted with 25 students, as well as two workshops held at the International Software Product Line Conference in 2014 and 2015 with both researchers and industry practitioners participating. We build upon the two surveys and the workshops to derive recommendations for educators to continue improving the state of practice of teaching SPLs, aimed at both individual educators as well as the wider community.
This document proposes exploiting the enumeration of all configurations of a feature model as a new perspective for automated reasoning with distributed computing. It discusses (1) enumerating configurations in parallel to improve scalability, (2) pre-compiling configurations offline to speed up costly operations like counting, core, and dead features, and (3) how the approach is not always best and depends on the feature model, operation, and time requirements. Preliminary evaluations show the approach is more efficient for large models but not always, and future work is needed to determine when enumeration is best versus traditional solvers.
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.
Paper was presented at SPLC'15
Many real-world product lines are only represented as non-hierarchical collections of distinct products, described by their configuration values. As the manual preparation of feature models is a tedious and labour-intensive activity, some techniques have been proposed to automatically generate boolean feature models from product descriptions. However , none of these techniques is capable of synthesizing feature attributes and relations among attributes, despite the huge relevance of attributes for documenting software product lines. In this paper, we introduce for the first time an algorithmic and parametrizable approach for computing a legal and appropriate hierarchy of features, including feature groups, typed feature attributes, domain values and relations among these attributes. We have performed an empirical evaluation by using both randomized configuration matrices and real-world examples. The initial results of our evaluation show that our approach can scale up to matrices containing 2,000 attributed features, and 200,000 distinct configurations in a couple of minutes.
Paper has been presented at SPLC'15 (Nashville, USA)
Variability is omnipresent in numerous kinds of artefacts (e.g., source code, product matrices) and in different shapes (e.g., conditional compilation, differences among product descriptions). For understanding, reasoning about, maintaining or evolving variability, practitioners usually need an explicit encoding of variability (ie a variability model). As a result, numerous techniques have been developed to reverse engineer variability (e.g., through the mining of features and constraints from source code) or for migrating a set of products as a variability system. In this talk we will first present tool-supported techniques for synthesizing variability models from constraints or product descriptions.
Practitioners can build Boolean feature models with an interactive environment for selecting a meaningful and sound hierarchy.
Attributes can also be synthesized for encoding numerical values and constraints among them.
We will present key results we obtain through experiments with the SPLOT repository and product comparison matrices coming from Wikipedia and BestBuy.
Finally we will introduce OpenCompare.org a recent initiative for editing, reasoning, and mining product comparison matrices.
This talk has been done at REVE'15 workshop co-located with SPLC'15 (software product line conference): http://www.isse.jku.at/reve2015/program.html
Pandoc (http://pandoc.org/) is a universal document converter. Taking as input Markdown/Wiki-like syntax, you can obtain an .odt, .docx, .tex, or even Beamer slides (like here)!
In this presentation we introduce Pandoc.
We then zoom on some interesting technical details (parameters, template language, ability to embed LaTeX into Markdown, ways to rewrite your AST with external bindings, etc.)
We believe Pandoc is a very useful piece of software that is worth studying (including for education/research purposes).
The slides have been written by Erwan Bousse (http://people.irisa.fr/Erwan.Bousse/) in Pandoc (of course!) and presented in the context of the DiverSE coffee (a weekly meeting of the DiverSE team: http://diverse.irisa.fr).
#1 The diversity of terminology shows the large spectrum of shapes DSLs can take.
#2 As syntax and development environment matter, DSLs should allow the user to choose the right shape according to their usage or task.
#3 A metamorphic DSL vision is proposed where DSLs can adapt to the most appropriate shape, including transitioning between shapes based on usage or task.
The document discusses customization and 3D printing from a software product line perspective. The researchers observed the Thingiverse community to see how they interact and collaborate to customize and produce 3D models. They found that while variability concepts are present, there is no constraints modeling and configuration leads to many issues due to huge complexity with 38 parameters across 8 tabs and 10^28 possible configurations. Software product line engineering techniques like variability modeling and implementation could help address challenges of complexity and cognitive effort for non-software developers customizing 3D models, but may not provide clear benefits for small communities in garages. Future work includes automated techniques to better analyze large datasets and help communities manage complexity.
Feature Models (FMs) are the de-facto standard for documenting, model checking, and reasoning about the configurations of a software system. This paper introduces WebFML a comprehensive environment for synthesizing FMs from various kinds of artefacts (e.g. propositional formula, dependency graph, FMs or product comparison matrices). A key feature of WebFML is an interactive support (through ranking lists, clusters, and logical heuristics) for choosing a sound and meaningful hierarchy. WebFML opens avenues for numerous practical applications (e.g., merging multiple product lines, slicing a configuration process, reverse engineering configurable systems).
tinyurl.com/WebFMLDemo
With around two decades of existence, the community of Software Product Line (SPL) researchers and practitioners is thriving as can be attested by the extensive research output and the numerous successful industrial projects. Education has a key role to support the next generation of engineers to build highly complex SPLs. Yet, it is unclear how SPLs are taught, what are the possible missing gaps and difficulties faced, what are the benefits, or what is the material available. In this paper, we carry out a survey with over 30 respondents with the purpose of capturing a snapshot of the state of teaching in our community. We report and discuss quantitative as well as qualitative results of the survey. We build upon them and sketch six concrete actions to continue improving the state of practice of SPL teaching.
This document summarizes a research paper presented at the ASE'13 conference about bridging the gap between product comparison matrices (PCMs) and variability models (VMs). The researchers conducted a case study of over 300 PCMs from Wikipedia to understand the types of information in PCMs and gaps with VMs. They identified 8 variability patterns in PCMs through qualitative and quantitative analysis. Their research aims to enable analysis of PCMs using VMs and generate product configurators and comparators from PCMs and VMs.
This document provides an overview of a tutorial on model-based variability management. It discusses research conducted at INRIA on managing variability in software systems using modeling techniques. The tutorial will cover three main topics: 1) why modeling and managing variability is important, 2) managing variability models using FAMILIAR, and 3) model-based derivation of product variants with examples, tools, and open issues. It aims to provide attendees with an understanding of ongoing work in the field and techniques that can be applied in practical and academic contexts.
More from University of Rennes, INSA Rennes, Inria/IRISA, CNRS (20)
ESPP presentation to EU Waste Water Network, 4th June 2024 “EU policies driving nutrient removal and recycling
and the revised UWWTD (Urban Waste Water Treatment Directive)”
ESR spectroscopy in liquid food and beverages.pptxPRIYANKA PATEL
With increasing population, people need to rely on packaged food stuffs. Packaging of food materials requires the preservation of food. There are various methods for the treatment of food to preserve them and irradiation treatment of food is one of them. It is the most common and the most harmless method for the food preservation as it does not alter the necessary micronutrients of food materials. Although irradiated food doesn’t cause any harm to the human health but still the quality assessment of food is required to provide consumers with necessary information about the food. ESR spectroscopy is the most sophisticated way to investigate the quality of the food and the free radicals induced during the processing of the food. ESR spin trapping technique is useful for the detection of highly unstable radicals in the food. The antioxidant capability of liquid food and beverages in mainly performed by spin trapping technique.
When I was asked to give a companion lecture in support of ‘The Philosophy of Science’ (https://shorturl.at/4pUXz) I decided not to walk through the detail of the many methodologies in order of use. Instead, I chose to employ a long standing, and ongoing, scientific development as an exemplar. And so, I chose the ever evolving story of Thermodynamics as a scientific investigation at its best.
Conducted over a period of >200 years, Thermodynamics R&D, and application, benefitted from the highest levels of professionalism, collaboration, and technical thoroughness. New layers of application, methodology, and practice were made possible by the progressive advance of technology. In turn, this has seen measurement and modelling accuracy continually improved at a micro and macro level.
Perhaps most importantly, Thermodynamics rapidly became a primary tool in the advance of applied science/engineering/technology, spanning micro-tech, to aerospace and cosmology. I can think of no better a story to illustrate the breadth of scientific methodologies and applications at their best.
Deep Behavioral Phenotyping in Systems Neuroscience for Functional Atlasing a...Ana Luísa Pinho
Functional Magnetic Resonance Imaging (fMRI) provides means to characterize brain activations in response to behavior. However, cognitive neuroscience has been limited to group-level effects referring to the performance of specific tasks. To obtain the functional profile of elementary cognitive mechanisms, the combination of brain responses to many tasks is required. Yet, to date, both structural atlases and parcellation-based activations do not fully account for cognitive function and still present several limitations. Further, they do not adapt overall to individual characteristics. In this talk, I will give an account of deep-behavioral phenotyping strategies, namely data-driven methods in large task-fMRI datasets, to optimize functional brain-data collection and improve inference of effects-of-interest related to mental processes. Key to this approach is the employment of fast multi-functional paradigms rich on features that can be well parametrized and, consequently, facilitate the creation of psycho-physiological constructs to be modelled with imaging data. Particular emphasis will be given to music stimuli when studying high-order cognitive mechanisms, due to their ecological nature and quality to enable complex behavior compounded by discrete entities. I will also discuss how deep-behavioral phenotyping and individualized models applied to neuroimaging data can better account for the subject-specific organization of domain-general cognitive systems in the human brain. Finally, the accumulation of functional brain signatures brings the possibility to clarify relationships among tasks and create a univocal link between brain systems and mental functions through: (1) the development of ontologies proposing an organization of cognitive processes; and (2) brain-network taxonomies describing functional specialization. To this end, tools to improve commensurability in cognitive science are necessary, such as public repositories, ontology-based platforms and automated meta-analysis tools. I will thus discuss some brain-atlasing resources currently under development, and their applicability in cognitive as well as clinical neuroscience.
The binding of cosmological structures by massless topological defectsSérgio Sacani
Assuming spherical symmetry and weak field, it is shown that if one solves the Poisson equation or the Einstein field
equations sourced by a topological defect, i.e. a singularity of a very specific form, the result is a localized gravitational
field capable of driving flat rotation (i.e. Keplerian circular orbits at a constant speed for all radii) of test masses on a thin
spherical shell without any underlying mass. Moreover, a large-scale structure which exploits this solution by assembling
concentrically a number of such topological defects can establish a flat stellar or galactic rotation curve, and can also deflect
light in the same manner as an equipotential (isothermal) sphere. Thus, the need for dark matter or modified gravity theory is
mitigated, at least in part.
Unlocking the mysteries of reproduction: Exploring fecundity and gonadosomati...AbdullaAlAsif1
The pygmy halfbeak Dermogenys colletei, is known for its viviparous nature, this presents an intriguing case of relatively low fecundity, raising questions about potential compensatory reproductive strategies employed by this species. Our study delves into the examination of fecundity and the Gonadosomatic Index (GSI) in the Pygmy Halfbeak, D. colletei (Meisner, 2001), an intriguing viviparous fish indigenous to Sarawak, Borneo. We hypothesize that the Pygmy halfbeak, D. colletei, may exhibit unique reproductive adaptations to offset its low fecundity, thus enhancing its survival and fitness. To address this, we conducted a comprehensive study utilizing 28 mature female specimens of D. colletei, carefully measuring fecundity and GSI to shed light on the reproductive adaptations of this species. Our findings reveal that D. colletei indeed exhibits low fecundity, with a mean of 16.76 ± 2.01, and a mean GSI of 12.83 ± 1.27, providing crucial insights into the reproductive mechanisms at play in this species. These results underscore the existence of unique reproductive strategies in D. colletei, enabling its adaptation and persistence in Borneo's diverse aquatic ecosystems, and call for further ecological research to elucidate these mechanisms. This study lends to a better understanding of viviparous fish in Borneo and contributes to the broader field of aquatic ecology, enhancing our knowledge of species adaptations to unique ecological challenges.
This presentation explores a brief idea about the structural and functional attributes of nucleotides, the structure and function of genetic materials along with the impact of UV rays and pH upon them.
ANAMOLOUS SECONDARY GROWTH IN DICOT ROOTS.pptxRASHMI M G
Abnormal or anomalous secondary growth in plants. It defines secondary growth as an increase in plant girth due to vascular cambium or cork cambium. Anomalous secondary growth does not follow the normal pattern of a single vascular cambium producing xylem internally and phloem externally.
hematic appreciation test is a psychological assessment tool used to measure an individual's appreciation and understanding of specific themes or topics. This test helps to evaluate an individual's ability to connect different ideas and concepts within a given theme, as well as their overall comprehension and interpretation skills. The results of the test can provide valuable insights into an individual's cognitive abilities, creativity, and critical thinking skills
2. Summer School EIT Digital.
5th July Rennes 2022
Abstract : Software has eaten the world and will continue to impact society,
spanning numerous application domains, including the way we're doing science and
acquiring knowledge.
Software variability is key since developers, engineers, entrepreneurs, scientists can
explore different hypothesis, methods, and custom products to hopefully fit a
diversity of needs and usage.
In this talk, I will first illustrate the importance of software variability using different
concrete examples.
I will then show that, though highly desirable, software variability also introduces an
enormous complexity due to the combinatorial explosion of possible variants.
For example, 10^6000 variants of the Linux kernel may be build, much more than the
estimated number of atoms in the universe (10^80).
Hence, the big picture and challenge for the audience: any organization capable of
mastering software variability will have a competitive advantage.
2
3. Software variants are eating the world
Software variability for supporting innovation and
science Improving, Adapting, Exploring, Creating cutting-edge products
Software science and software variability Challenges
ahead!
Agenda
3
6. Science now depends on
software and its engineering
6
design of mathematical model
mining and analysis of data
executions of large simulations
problem solving
executable paper
from a set of scripts to automate the deployment to… a
comprehensive system containing several features that
help researchers exploring various hypotheses
7. 7
from a set of scripts to automate the deployment to… a
comprehensive system containing several features that
help researchers exploring various hypotheses
multi-million line of code base
multi-dependencies
multi-systems
multi-layer
multi-version
multi-person
multi-variant
Science now depends on
software and its engineering
8. 8
Dealing with software collapse: software stops working eventually
Konrad Hinsen 2019
Configuration failures represent one of the most common types of
software failures Sayagh et al. TSE 2018
multi-million line of code base
multi-dependencies
multi-systems
multi-layer
multi-version
multi-person
multi-variant
Science now depends on
software and its engineering
15. “Reverse Engineering Web Configurators” Ebrahim Khalil Abbasi, Mathieu Acher, Patrick Heymans, and Anthony
Cleve. In 17th European Conference on Software Maintenance and Reengineering (CSMR'14) 15
16. Software variants are eating the world
Software variability for supporting innovation and
science Improving, Adapting, Exploring, Creating cutting-edge products
Software science and software variability Challenges ahead!
Agenda
16
17. Too many knobs and variability?
default configurations are
suboptimal Xu et al. FSE 2015
17
18. Best configuration is 480 times better
than Worst configuration
Only by tweaking 2 options out of 200 in Apache
Storm observed ~100% change in latency
Best
Worst
Perhaps… but missing opportunities with
software variability!
Jamshidi et al. An Uncertainty-Aware Approach to Optimal
Configuration of Stream Processing Systems MASCOT’16
18
19. Best configuration is 480 times better
than Worst configuration
Only by tweaking 2 options out of 200 in Apache
Storm observed ~100% change in latency
Best
Worst
Mastering software variability for
delivering faster while consuming less energy
Jamshidi et al. An Uncertainty-Aware Approach to Optimal
Configuration of Stream Processing Systems MASCOT’16
19
20. 20
Mathieu Acher, Benoit Baudry, Olivier Barais, Jean-Marc Jézéquel: Customization and
3D printing: a challenging playground for software product lines. SPLC 2014: 142-146
21. 21
Mastering software variability for
avoiding configuration errors and assisting users in finding the right products
Benoit Amand, Maxime Cordy, Patrick Heymans, Mathieu Acher, Paul Temple, Jean-Marc Jézéquel Towards
Learning-Aided Configuration in 3D Printing: Feasibility Study and Application to Defect Prediction VaMoS 2019
22. ● Web-apps generator
○ Spring-Boot
○ Bootstrap / AngularJS
○ Open Source
● Yeoman
○ Bower, npm
○ yo
● Used all over the world
○ Large companies (HBO, Google, Adobe)1
○ Independent developers
○ Our students
● JHipster 3.6.1, 18 Aug 2016
○ 6000+ stars
○ 118 releases
○ 300+ contributors
22
Mastering software variability for
adapting to your technological constraints or know-how
A. Halin, A. Nuttinck, M. Acher, X. Devroey, G. Perrouin and B. Baudry, “Test them
all, is it worth it? Assessing configuration sampling on the JHipster Web develop-
ment stack”, Empirical Software Engineering (ESE)
23. José A. Galindo, Mauricio Alférez, Mathieu Acher, Benoit Baudry, David Benavides: A variability-based testing approach for
synthesizing video sequences. ISSTA 2014
Mastering software variability for
synthesizing a diversity of input data either for training or testing!
23
24. Mastering software variability for
exploring different variants (= PDF papers) that fit your requirements
Mathieu Acher, Paul Temple, Jean-Marc Jézéquel, José Ángel Galindo Duarte, Jabier Martinez, Tewfik Ziadi
VaryLaTeX: Learning Paper Variants That Meet Constraints VaMoS 2020
24
25. ?????
Mastering software variability for
predicting performance of a system (without running it!)
J. Alves Pereira, M. Acher, H. Martin and J.-M. Jézéquel,
“Sampling Effect on Performance Prediction of Configurable
Systems: A Case Study” ICPE’20, Best paper award 25
26. compile-time
options
L. Lesoil, M. Acher, X. Tërnava, A. Blouin and J.-M. Jézéquel “The
Interplay of Compile-time and Run-time Options for Performance
Prediction” in SPLC ’21
Mastering software variability for
predicting performance of a system (without running it!)
26
28. [Xu et al., FSE 2015]
[Passos et al., TSE 2016]
Huge variability space: impossible to execute, obs
and label all configurations/variants in practice!
33 options = more configurations than humans on earth
320 options = more configurations than estimated atoms in the unive
28
30. Huge variability space: impossible to execute, observe, and label all
configurations in practice
Key idea: learning out of a sample of configurations that is
hopefully small/representative of the whole space
J. Alves Pereira, H. Martin, M. Acher, J.-M. Jézéquel, G. Botterweck and A. Ventresque
“Learning Software Configuration Spaces: A Systematic Literature Review” JSS, 2021
30
39. Challenge 1: you cannot build ≈106000
configurations; sampling and learning to the
rescue but how? and what about cost?
7.1Mb
176.8Mb
?
Variability
in
space
39
40. A challenging case
● Linear-based algorithms : high error rate (it’s not additive!)
● Polynomial regression & performance-influence model : Out Of Memory (too much interactions and
not designed for 9K+ options)
● Tree-based algorithms & neural networks: low error rate
Mean Absolute Percentage Error
(MAPE): the lower the better
40
Mathieu Acher, Hugo Martin, Juliana Alves Pereira, Arnaud Blouin, Jean-Marc Jézéquel, Djamel Eddine Khelladi, Luc Lesoil, and Olivier Barais.
Learning Very Large Configuration Spaces: What Matters for Linux Kernel Sizes (2019) https://hal.inria.fr/hal-02314830
N : percentage of the
dataset used to training
(95K in total)
for Linux 4.13.3
41. Challenge 2: Linux evolves; (heterogeneous)
transfer learning!
7.1Mb
176.8Mb
?
v4.13 v5.8
3 years
later…
?
?
?
Variability
in
space
…Variability in time… 41
42. Instead of learning from scratch or reusing “as is”,
we propose to transfer (adapt) a prediction model.
A problem overlooked in the literature is that the
feature spaces differ among versions since options
are added/removed.
We propose TEAMS for transfer evolution-aware
model shifting.
Key results:
Rapid degradation of prediction models due to evolution (up to 32% prediction errors)
Effective transfer learning with TEAMS (reaching same accuracy 3 years later + SOTA)
Possible to learn colossal configuration spaces such as the Linux kernel one across
variants and versions
42
43. Can we reuse a prediction model among versions?
No. Accuracy quickly
decreases:
○ 4.13: 6%
○ 4.15: 20%
○ 5.7: 35%
3
43
Insights about evolution of (important) options in the TSE article!
44. 4.13 version (sep 2017): 6%. What about evolution? Can we reuse the 4.13 Linux prediction
model? No, accuracy quickly decreases: 4.15 (5 months after): 20%; 5.7 (3 years after): 35%
3
44
45. Transfer learning to the rescue
● Mission Impossible: Saving variability knowledge and
prediction model 4.13 (15K hours of computation)
● Heterogeneous transfer learning: the feature space is
different
● TEAMS: transfer evolution-aware model shifting
5
45
H. Martin, M. Acher, J. A. Pereira, L. Lesoil, J. Jézéquel and D. E. Khelladi, “Transfer learning across variants
and versions: The case of linux kernel size” Transactions on Software Engineering (TSE), 2021
3
45
46. Published at IEEE Transactions on
Software Engineering (TSE) in 2021
Preprint: https://hal.inria.fr/hal-03358817
46
47. Software variants are eating the world
Software variability for supporting innovation and
science Improving, Adapting, Exploring, Creating cutting-edge products
Software science and software variability
Challenges ahead!
Agenda
47
48. 48
from a set of scripts to automate the deployment to… a
comprehensive system containing several features that
help researchers exploring various hypotheses
Software variability is key to scientific,
software-based experiments
49. (computational)
science
49
from a set of scripts to automate the deployment to… a
comprehensive system containing several features that
help researchers exploring various hypotheses
Software variability is a threat to
scientific, software-based experiments
50. “Neuroimaging pipelines are known to generate different results
depending on the computing platform where they are compiled and
executed.”
Reproducibility of neuroimaging
analyses across operating systems,
Glatard et al., Front. Neuroinform., 24
April 2015
The implementation of mathematical functions manipulating single-precision floating-point
numbers in libmath has evolved during the last years, leading to numerical differences in
computational results. While these differences have little or no impact on simple analysis
pipelines such as brain extraction and cortical tissue classification, their accumulation
creates important differences in longer pipelines such as the subcortical tissue
classification, RSfMRI analysis, and cortical thickness extraction.
50
51. Can a coupled ESM simulation be restarted from a different machine
without causing climate-changing modifications in the results?
A study involving eight institutions and seven different supercomputers in Europe is
currently ongoing with EC-Earth. This ongoing study aims to do the following:
● evaluate different computational environments that are used in collaboration
to produce CMIP6 experiments (can we safely create large ensembles
composed of subsets that emanate from different partners of the
consortium?);
● detect if the same CMIP6 configuration is replicable among platforms of the
EC-Earth consortium (that is, can we safely exchange restarts with EC-Earth
partners in order to initialize simulations and to avoid long spin-ups?); and
● systematically evaluate the impact of different compilation flag options (that
is, what is the highest acceptable level of optimization that will not break the
replicability of EC-Earth for a given environment?).
51
52. Joelle Pineau “Building Reproducible, Reusable, and Robust Machine Learning Software” ICSE’19 keynote “[...] results
can be brittle to even minor perturbations in the domain or experimental procedure”
What is the magnitude of the effect
hyperparameter settings can have on baseline
performance?
How does the choice of network architecture for
the policy and value function approximation affect
performance?
How can the reward scale affect results?
Can random seeds drastically alter performance?
How do the environment properties affect
variability in reported RL algorithm performance?
Are commonly used baseline implementations
comparable? 52
53. (computational)
science
53
from a set of scripts to automate the deployment to… a
comprehensive system containing several features that
help researchers exploring various hypotheses
Software variability is an opportunity
to robustify and augment scientific
knowledge (and thus for innovation)
54. Developers, engineers, entrepreneurs, scientists should
have the super-power of exploring variants with software
(new “configurations”, “products”, “ideas”, “hypotheses”...)
54
55. Challenge #0 Mastering deep software variability
Perf can be either
execution time,
energy
consumption,
accuracy, security,
etc. (or a
combination
thereof)
55
56. Challenge #1 Reducing the cost of exploring the
variability spaces/layers
Many directions here
● learning
○ many algorithms/techniques with tradeoffs interpretability/accuracy
○ transfer learning (instead of learning from scratch)
● sampling strategies
○ uniform random sampling? t-wise? distance-based? …
○ sample of hardware? input data?
● incremental build of configurations
● white-box approaches
● …
56
57. Challenge #2 Modelling deep variability
● Abstractions are definitely needed to…
○ reason about logical constraints and interactions
○ integrate domain knowledge
○ synthesize domain knowledge
○ automate and guide the exploration of variants
○ scope and prioritize experiments
● Challenges:
○ Multiple systems, layers, concerns
○ Different kinds of variability: technical vs domain, accidental vs
essential, implicit vs explicit… when to stop modelling?
○ reverse engineering 57
58. Challenge #3 Robustness (trustworthiness)
of scientific results to sources of variability
There are many examples of sources of variations (and non-robust
results).
Threats for science and innovation!
How to verify the effect of sources of variations on the robustness of
given conclusions?
● actionable metrics?
● methodology? (eg when to stop?)
● variability can actually be leveraged to augment confidence
58
60. (BEYOND x264) Empirical and fundamental question
HOW DOES DEEP
SOFTWARE VARIABILITY
MANIFEST IN THE WILD?
SOFTWARE
SCIENTISTS
should
OBSERVE the
JUNGLE/
GALAXY!
Age # Cores GPU
Variant
Compil. Version
Version Option Distrib.
Size Length Res.
Hardware
Operating
System
Software
Input Data
60
61. Deep Software Variability
4 challenges and opportunities
Luc Lesoil, Mathieu Acher, Arnaud Blouin, Jean-Marc Jézéquel:
Deep Software Variability: Towards Handling Cross-Layer Configuration. VaMoS 2021: 10:1-10:8
61
62. Identify the influential layers 1
Age # Cores GPU
Variant
Compil. Version
Version Option Distrib.
Size Length Res.
Hardware
Operating
System
Software
Input Data
Problem
≠ layers,
≠ importances on
performances
Challenge
Estimate their effects
Opportunity
Leverage the useful
variability layers
& variables
62
63. 2
Test & Benchmark environments
0.152.2854 0.155.2917
Problem
Combinatorial explosion and cost
Challenge
Build a
representative, cheap
set of environments
Opportunity
dimensionality reduction
Hardware
Operating
System
Software
Input Data
63
64. Transfer performances across environments
10.4
20.04
Dell latitude
7400
Raspberry Pi
4 model B
A B
?
Problem
Options’ importances
change with environments
Challenge
Transfer performances
across environments
Opportunity
Reduce cost of measure
3
64
65. Cross-Layer Tuning
Age # Cores GPU
Variant
Compil. Version
Version Option Distrib.
Size Length Res.
Hardware
Operating
System
Software
Input Data
4
Problem
(Negative) interactions
of layers
Challenge
Find & fix values to improve
performances
Opportunity
Specialize the environment
for a use case
Bug
Perf. ↗
Perf. ↘
65
66. CHALLENGES for Deep Software Variability
Identify the influential layers
Test & Benchmark environments
Transfer performances across environments
Cross-Layer Tuning
66
67. Wrap-up
Deep software variability is a thing…
miracle and smooth fit of variability layers?
or subtle interactions among layers?
software scientists should systematically study the phenomenon
Many challenges and opportunities
cross-layer tuning at affordable cost
configuration knowledge that generalizes to any context and usage
Dimensionality reduction and transfer learning
67
68. Impacts of deep software variability
Users/developers/scientists: missed opportunities due to (accidental) variability/complexity
Deep software variability can be seen as a threat to knowledge/validity
Claim: Deep software variability is a threat to scientific, software-based experiments
Example #1: in the results of neuroimaging studies
● applications of different analysis pipelines (Krefting et al. 2011)
● alterations in software version (Glatard et al. 2015)
● changes in operating system (Gronenschild2012 et al.)
have both shown to cause variation (up to the point it can change the conclusions).
Example #2: on a modest scale, our ICPE 2020 (Pereira et al.) showed that a variation in inputs could change the
conclusion about the effectiveness of a sampling strategy for the same software system.
Example #3: I’m reading Zakaria Ournani et al. “Taming Energy Consumption Variations In Systems Benchmarking”
ICPE 2020 as an excellent inquiry to control deep variability factors
Example #4: Similar observations have been made in the machine learning community (Henderson et al. 2018)
version
runtime options
OS
68
69. Impacts of deep software variability
Users/developers/scientists: missed opportunities due to (accidental) complexity
Deep software variability can be seen as a threat to knowledge/validity
Claim: Deep software variability is a threat to scientific, software-based experiments
I propose an exercise that might be slightly disturbing:
Does deep software variability affect (your|a known) previous
scientific, software-based studies?
(remark: it’s mainly how we’ve investigated deep software variability so far… either as a threat to our own
experiments or as a threat identified in papers)
69
70. Applications of different analysis pipelines, alterations in software version, and even changes in operating
system have both shown to cause variation in the results of a neuroimaging study. Example:
Joelle Pineau “Building Reproducible, Reusable, and Robust Machine Learning Software” ICSE’19 keynote
“[...] results can be brittle to even minor perturbations in the domain or experimental procedure” Example:
DEEP SOFTWARE
VARIABILITY
DEEP SOFTWARE
VARIABILITY
Deep software variability is a threat to
scientific, software-based experiments
70