SwePub
Sök i SwePub databas

  Utökad sökning

Träfflista för sökning "WFRF:(Berger Thorsten 1981) "

Sökning: WFRF:(Berger Thorsten 1981)

  • Resultat 1-50 av 76
Sortera/gruppera träfflistan
   
NumreringReferensOmslagsbildHitta
1.
  • Abukwaik, H., et al. (författare)
  • Semi-Automated Feature Traceability with Embedded Annotations
  • 2018
  • Ingår i: Proceedings 2018 IEEE International Conference on Software Maintenance and Evolution. - : IEEE. - 9781538678701
  • Konferensbidrag (refereegranskat)abstract
    • Engineering software amounts to implementing and evolving features. While some engineering approaches advocate the explicit use of features, developers usually do not record feature locations in software artifacts. However, when evolving or maintaining features-especially in long-living or variant-rich software with many developers-the knowledge about features and their locations quickly fades and needs to be recovered. While automated or semi-automated feature-location techniques have been proposed, their accuracy is usually too low to be useful in practice. We propose a semi-automated, machine-learning-assisted feature-traceability technique that allows developers to continuously record feature-traceability information while being supported by recommendations about missed locations. We show the accuracy of our proposed technique in a preliminary evaluation, simulating the engineering of an open-source web-application that evolved in different, cloned variants.
  •  
2.
  • Andam, Berima, 1986, et al. (författare)
  • Florida: Feature LOcatIon DAshboard for extracting and visualizing feature traces
  • 2017
  • Ingår i: Proceedings of the Eleventh International Workshop on Variability Modelling of Software-intensive Systems, VaMoS 2017. - New York, NY, USA : ACM. ; Part F126227, s. 100-107
  • Konferensbidrag (refereegranskat)abstract
    • © 2017 Copyright held by the owner/author(s). Features are high-level, domain-specific abstractions over implementation artifacts. Developers use them to communicate and reason about a system, in order to maintain and evolve it. These activities, however, require knowing the locations of features - a common challenge when a system has many developers, many (cloned) variants, or a long lifespan. We believe that embedding feature-location information into software artifacts via annotations eases typical feature-related engineering tasks, such as modifying and removing features, or merging cloned features into a product line. However, regardless of where such annotations stem from - whether embedded by developers when writing code, or retroactively recovered using a feature-location technique - tool support is needed for developers to exploit such annotations. In this tool demonstration, we present a lightweight tool that extracts annotations from software artifacts, aggregates and processes them, and visualizes feature-related information for developers. Views, such as which files implement a specific feature, are presented on different levels of abstraction. Feature metrics, such as feature size, feature scattering, feature tangling, and numbers of feature authors, are also presented. Our tool also incorporates an information-retrieval-based feature-location technique to retroactively recover feature locations.
  •  
3.
  • Barros, Djonathan, et al. (författare)
  • Editing Support for Software Languages: Implementation Practices in Language Server Protocols (Summary)
  • 2023
  • Ingår i: Lecture Notes in Informatics. - 1617-5468. ; P-332, s. 35-36
  • Konferensbidrag (refereegranskat)abstract
    • We present our paper published at the 25th International Conference on Model Driven Engineering Languages and Systems (MODELS) [Ba22a]. Effectively using software languages requires effective editing support. Modern IDEs, modeling tools, and code editors typically provide sophisticated support to create, comprehend, or modify instancesof particular languages. Unfortunately, building such editing support is challenging. While the engineering of languages is well understood and supported by modern model-driven techniques, there is a lack of engineering principles and best practices for realizing their editing support. We study practices for implementing editing support in so-called language servers-implementations of the language server protocol (LSP). LSP is a recent de facto standard to realize editing support for languages, separated from the editing tools, enhancing the reusability and quality of the editing support. Witnessing the LSP's popularity, we take this opportunity to analyze the implementations of 30 language servers. We identify concerns that developers need to take into account when developing editing support, and we synthesize implementation practices to address them, based on a systematic analysis of the servers' source code. We hope that our results shed light on an important technology for software language engineering, that facilitates language-oriented programming and systems development, including model-driven engineering.
  •  
4.
  • Behringer, Benjamin, et al. (författare)
  • PEoPL: Projectional Editing of Product Lines
  • 2017
  • Ingår i: Proceedings - 2017 IEEE/ACM 39th International Conference on Software Engineering, ICSE 2017. - : IEEE. ; , s. 563-574
  • Konferensbidrag (refereegranskat)abstract
    • © 2017 IEEE. The features of a software product line-a portfolio of system variants-can be realized using various implementation techniques (a. k. a., variability mechanisms). Each technique represents the software artifacts of features differently, typically classified into annotative (e.g., C preprocessor) and modular representations (e.g., feature modules), each with distinct advantages and disadvantages. Annotative representations are easy to realize, but annotations clutter source code and hinder program comprehension. Modular representations support comprehension, but are difficult to realize. Most importantly, to engineer feature artifacts, developers need to choose one representation and adhere to it for evolving and maintaining the same artifacts. We present PEoPL, an approach to combine the advantages of annotative and modular representations. When engineering a feature artifact, developers can choose the most-suited representation and even use different representations in parallel. PEoPL relies on separating a product line into an internal and external representation, the latter by providing editable projections used by the developers. We contribute a programming-language-independent internal representation of variability, five editable projections reflecting different variability representations, a supporting IDE, and a tailoring of PEoPL to Java. We evaluate PEoPL's expressiveness, scalability, and flexibility in eight Java-based product lines, finding that all can be realized, that projections are feasible, and that variant computation is fast (
  •  
5.
  • Bergel, Alexandre, et al. (författare)
  • FeatureVista: interactive feature visualization
  • 2021
  • Ingår i: SPLC '21: Proceedings of the 25th ACM International Systems and Software Product Line Conference. - New York, NY, USA : ACM. - 9781450384698 ; Volume A:September 2021, s. 196-201
  • Konferensbidrag (refereegranskat)abstract
    • Comprehending and characterizing the spread and interaction of features in a software system is know to be difficult and error-prone. This paper presents FeatureVista, a lightweight tool providing interactive, glyph-based, and iconic visualization concepts designed to visually characterize the feature locations in software assets (source code). FeatureVista supports navigating between software components and features in an equal fashion. Our pilot study indicates that FeatureVista is intuitive and supports comprehending features. It helps to precisely characterize relations among features in large software systems and to contrast explicit software component definitions (e.g., package, class, method) with annotated feature portions---which so far was a largely manual and error-prone activity, albeit essential to get an adequate understanding of a software system. We suggest research directions for true, feature-oriented interfaces that can be used to manage software assets.
  •  
6.
  •  
7.
  • Berger, Thorsten, 1981, et al. (författare)
  • The state of adoption and the challenges of systematic variability management in industry
  • 2020
  • Ingår i: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; :25, s. 1755-1797
  • Tidskriftsartikel (refereegranskat)abstract
    • Handling large-scale software variability is still a challenge for many organizations. After decades of research on variability management concepts, many industrial organizations have introduced techniques known from research, but still lament that pure textbook approaches are not applicable or efficient. For instance, software product line engineering-an approach to systematically develop portfolios of products-is difficult to adopt given the high upfront investments; and even when adopted, organizations are challenged by evolving their complex product lines. Consequently, the research community now mainly focuses on re-engineering and evolution techniques for product lines; yet, understanding the current state of adoption and the industrial challenges for organizations is necessary to conceive effective techniques. In this multiple-case study, we analyze the current adoption of variability management techniques in twelve medium- to large-scale industrial cases in domains such as automotive, aerospace or railway systems. We identify the current state of variability management, emphasizing the techniques and concepts they adopted. We elicit the needs and challenges expressed for these cases, triangulated with results from a literature review. We believe our results help to understand the current state of adoption and shed light on gaps to address in industrial practice.
  •  
8.
  • Berger, Thorsten, 1981, et al. (författare)
  • Usage Scenarios for a Common Feature Modeling Language
  • 2020
  • Ingår i: SPLC '19: Proceedings of the 23rd International Systems and Software Product Line Conference - Volume B. pp. 174–181. - New York, NY, USA : ACM. - 9781450366687
  • Konferensbidrag (refereegranskat)abstract
    • Feature models are recognized as a de facto standard for variability modeling. Presented almost three decades ago, dozens of different variations and extensions to the original feature-modeling notation have been proposed, together with hundreds of variability management techniques building upon feature models. Unfortunately, despite several attempts to establish a unified language, there is still no emerging consensus on a feature-modeling language that is both intuitive and simple, but also expressive enough to cover a range of important usage scenarios. There is not even a documented and commonly agreed set of such scenarios. Following an initiative among product-line engineering researchers in September 2018, we present 14 usage scenarios together with examples and requirements detailing each scenario. The scenario descriptions are the result of a systematic process, where members of the initiative authored original descriptions, which received feedback via a survey, and which we then refined and extended based on the survey results, reviewers' comments, and our own expertise. We also report the relevance of supporting each usage scenario for the language, as perceived by the initiative's members, prioritizing each scenario. We present a roadmap to build and implement a first version of the envisaged common language.
  •  
9.
  • Bilic, Damir (författare)
  • Managing Variability in SysML Models of Automotive Systems
  • 2020
  • Licentiatavhandling (övrigt vetenskapligt/konstnärligt)abstract
    • Organizations developing software-intensive systems inevitably face increasing complexity of developed products, mainly due to rapid advancements in all domains of technology. Many such organizations are considering model-based systems engineering (MBSE) practices to cope with the increasing complexity. The use of models, as a central role during product design, promises to provide benefits such as enhanced communication among system stakeholders, continuous verification, improved design integrity, traceability between requirements and system artifacts and many more. Additionally, products are often built in many variants. That is especially obvious in the automotive domain, where customers have the ability to configure vehicles with hundreds of configuration options. To deal with the variability, a product line engineering approach is often used. It allows the development of a family of similar software-intensive systems that share a common base while being adapted to individual customer requirements.In this thesis, the overall goal is to evaluate and facilitate the combination of the two mentioned approaches, model-based systems engineering and product line engineering, in an industrial environment. To achieve the main thesis goal, it was divided into three separate research goals.The first goal was to identify challenges when applying an annotation-based approach for variant management in SysML models on a use case provided by Volvo Construction Equipment. The aim was to identify and understand challenges when using existing tool support to manage variants in implementation artifacts of existing products. The second research goal was to identify reuse-related challenges in the ``clone-and-own'' based development process of Volvo CE. Moreover, we assess the effects of model-based product line engineering on the identified challenges. Lastly, the third research goal was to develop an approach for consistency checking between variability- and SysML system models. To achieve that, we develop an integrated tool chain for model-based product line engineering that allows the integration of variable artifacts, which are not documented in system models, into the development process. Secondly, we define and develop an approach for consistency checking between variability models that describe the system in terms of features and implementation models that describe how variability is implemented in the product itself, since such support does not exist in current state of the art tools.In conclusion, based on the results from the results of case studies at Volvo CE, it was shown that model-based product line engineering has the potential to improve communication and highlight implications of variability to stakeholders (e.g. to non-technical staff), improve traceability between variability in requirements and variability in design and implementation, improve consistency through constraints between variants and automate repetitive activities.In other words, it shows potential for improving product quality while reducing the development lead time. However, the evaluation and measurement of improvement will be left for future work as measuring the product quality and lead time requires an organizational roll out of model-based product-line engineering.
  •  
10.
  • Businge, J., et al. (författare)
  • Clone-Based Variability Management in the Android Ecosystem
  • 2018
  • Ingår i: Proceedings-IEEE International Conference on Software Maintenance. - : IEEE. - 9781538678701
  • Konferensbidrag (refereegranskat)abstract
    • Mobile app developers often need to create variants to account for different customer segments, payment models or functionalities. A common strategy is to clone (or fork) an existing app and then adapt it to new requirements. This form of reuse has been enhanced with the advent of social-coding platforms such as Github, cultivating a more systematic reuse. Different facilities, such as forks, pull requests, and cross-project traceability support clone-based development. Unfortunately, even though, many apps are known to be maintained in many variants, little is known about how practitioners manage variants of mobile apps. We present a study that explores clone-based reuse practices for open-source Android apps. We identified and analyzed families of apps that are maintained together and that exist both on the official app store (Google Play) as well as on Github, allowing us to analyze reuse practices in depth. We mined both repositories to identify app families and to study their characteristics, including their variabilities as well as code-propagation practices and maintainer relationships. We found that, indeed, app families exist and that forked app variants fall into the following categories: (i) re-branding and simple customizations, (ii) feature extension, (iii) supporting of the mainline app, and (iv) implementation of different, but related features. Other notable characteristic of the app families we discovered include: (i) 73% of the app families did not perform any form of code propagation, and (ii) 74% of the app families we studied do not have common maintainers.
  •  
11.
  • Businge, John, et al. (författare)
  • Clone-based variability management in the android ecosystem
  • 2018
  • Ingår i: Proceedings - 2018 IEEE International Conference on Software Maintenance and Evolution, ICSME 2018. - 9781538678701 ; , s. 625-634
  • Konferensbidrag (refereegranskat)abstract
    • Mobile app developers often need to create variants to account for different customer segments, payment models or functionalities. A common strategy is to clone (or fork) an existing app and then adapt it to new requirements. This form of reuse has been enhanced with the advent of social-coding platforms such as Github, cultivating a more systematic reuse. Different facilities, such as forks, pull requests, and cross-project traceability support clone-based development. Unfortunately, even though, many apps are known to be maintained in many variants, little is known about how practitioners manage variants of mobile apps. We present a study that explores clone-based reuse practices for open-source Android apps. We identified and analyzed families of apps that are maintained together and that exist both on the official app store (Google Play) as well as on Github, allowing us to analyze reuse practices in depth. We mined both repositories to identify app families and to study their characteristics, including their variabilities as well as code-propagation practices and maintainer relationships. We found that, indeed, app families exist and that forked app variants fall into the following categories: (i) re-branding and simple customizations, (ii) feature extension, (iii) supporting of the mainline app, and (iv) implementation of different, but related features. Other notable characteristic of the app families we discovered include: (i) 72.7% of the app families did not perform any form of code propagation, and (ii) 74% of the app families we studied do not have common maintainers.
  •  
12.
  • Businge, J., et al. (författare)
  • Reuse and maintenance practices among divergent forks in three software ecosystems
  • 2022
  • Ingår i: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; 27:2
  • Tidskriftsartikel (refereegranskat)abstract
    • With the rise of social coding platforms that rely on distributed version control systems, software reuse is also on the rise. Many software developers leverage this reuse by creating variants through forking, to account for different customer needs, markets, or environments. Forked variants then form a so-called software family; they share a common code base and are maintained in parallel by same or different developers. As such, software families can easily arise within software ecosystems, which are large collections of interdependent software components maintained by communities of collaborating contributors. However, little is known about the existence and characteristics of such families within ecosystems, especially about their maintenance practices. Improving our empirical understanding of such families will help build better tools for maintaining and evolving such families. We empirically explore maintenance practices in such fork-based software families within ecosystems of open-source software. Our focus is on three of the largest software ecosystems existence today: Android, .NET, and JavaScript. We identify and analyze software families that are maintained together and that exist both on the official distribution platform (Google play, nuget, and npm) as well as on GitHub , allowing us to analyze reuse practices in depth. We mine and identify 38 software families, 526 software families, and 8,837 software families from the ecosystems of Android, .NET, and JavaScript, to study their characteristics and code-propagation practices. We provide scripts for analyzing code integration within our families. Interestingly, our results show that there is little code integration across the studied software families from the three ecosystems. Our studied families also show that techniques of direct integration using git outside of GitHub is more commonly used than GitHub pull requests. Overall, we hope to raise awareness about the existence of software families within larger ecosystems of software, calling for further research and better tools support to effectively maintain and evolve them.
  •  
13.
  • Da Silva, L., et al. (författare)
  • Detecting Semantic Conflicts via Automated Behavior Change Detection
  • 2020
  • Ingår i: 2020 IEEE International Conference on Software Maintenance and Evolution (ICSME). - : IEEE. - 9781728156194 ; , s. 174-184
  • Bokkapitel (övrigt vetenskapligt/konstnärligt)abstract
    • Branching and merging are common practices in collaborative software development. They increase developer productivity by fostering teamwork, allowing developers to independently contribute to a software project. Despite such benefits, branching and merging comes at a cost-the need to merge software and to resolve merge conflicts, which often occur in practice. While modern merge techniques, such as 3-way or structured merge, can resolve many such conflicts automatically, they fail when the conflict arises not at the syntactic, but the semantic level. Detecting such conflicts requires understanding the behavior of the software, which is beyond the capabilities of most existing merge tools. As such, semantic conflicts can only be identified and fixed with significant effort and knowledge of the changes to be merged. While semantic merge tools have been proposed, they are usually heavyweight, based on static analysis, and need explicit specifications of program behavior. In this work, we take a different route and explore the automated creation of unit tests as partial specifications to detect unwanted behavior changes (conflicts) when merging software. We systematically explore the detection of semantic conflicts through unit-test generation. Relying on a ground-truth dataset of 38 software merge scenarios, which we extracted from GitHub, we manually analyzed them and investigated whether semantic conflicts exist. Next, we apply test-generation tools to study their detection rates. We propose improvements (code transformations) and study their effectiveness, as well as we qualitatively analyze the detection results and propose future improvements. For example, we analyze the generated test suites for false-negative cases to understand why the conflict was not detected. Our results evidence the feasibility of using test-case generation to detect semantic conflicts as a method that is versatile and requires only limited deployment effort in practice, as well as it does not require explicit behavior specifications.
  •  
14.
  • Da Silva, Léuson, et al. (författare)
  • Detecting semantic conflicts with unit tests
  • 2024
  • Ingår i: Journal of Systems and Software. - 0164-1212. ; 214
  • Tidskriftsartikel (refereegranskat)abstract
    • While modern merge techniques, such as 3-way and structured merge, can resolve textual conflicts automatically, they fail when the conflict arises not at the syntactic, but at the semantic level. Detecting such semantic conflicts requires understanding the behavior of the software, which is beyond the capabilities of most existing merge tools. Although semantic merge tools have been proposed, they are usually based on heavyweight static analyses, or need explicit specifications of program behavior. In this work, we take a different route and propose SAM (SemAntic Merge), a semantic merge tool based on the automated generation of unit tests that are used as partial specifications of the changes to be merged, and that drive the detection of unwanted behavior changes (conflicts) when merging software. To evaluate SAM's feasibility for detecting conflicts, we perform an empirical study relying on a dataset of more than 80 pairs of changes integrated to common class elements (constructors, methods, and fields) from 51 merge scenarios. We also assess how the four unit test generation tools used by SAM individually contribute to conflict identification. Our results show that SAM performs best when combining only the tests generated by Differential EvoSuite and EvoSuite, and using our proposed testability transformations (nine detected conflicts out of 29). These results reinforce previous findings about the potential of using test-case generation to detect conflicts as a method that is versatile and requires only limited deployment effort in practice.
  •  
15.
  • Debbiche, Jamel, et al. (författare)
  • Migrating Java-based apo-games into a composition-based software product line
  • 2019
  • Ingår i: PervasiveHealth: Pervasive Computing Technologies for Healthcare. - New York, NY, USA : ACM. - 2153-1633. ; A
  • Konferensbidrag (refereegranskat)abstract
    • A software product line enables an organization to systematically reuse software features that allow to derive customized variants from a common platform, promising reduced development and maintenance costs. In practice, however, most organizations start to clone existing systems and only extract a software product line from such clones when the maintenance and coordination costs increase. Despite the importance of extractive software-product-line adoption, we still have only limited knowledge on what practices work best and miss datasets for evaluating automated techniques. To improve this situation, we performed an extractive adoption of the Apo-Games, resulting in a systematic analysis of fve Java games and the migration of three games into a composition-based software product line. In this paper, we report our analysis and migration process, discuss our lessons learned, and contribute a feature model as well as the implementation of the extracted software product line. Overall, the results help to gain a better understanding of problems that can appear during such migrations, indicating research opportunities and hints for practitioners. Moreover, our artifacts can serve as dataset to test automated techniques and developers may improve or extent them in the future.
  •  
16.
  • Derks, C., et al. (författare)
  • A benchmark generator framework for evolving variant-rich software
  • 2023
  • Ingår i: Journal of Systems and Software. - 0164-1212. ; 203
  • Tidskriftsartikel (refereegranskat)abstract
    • Software often needs to exist in different variants, which account for varying customer requirements, environments, or non-functional aspects, such as energy consumption. Unfortunately, the number of variants can grow exponentially with the number of features. As such, developing and evolving variant-rich systems is challenging, since they do not only evolve "in time"as single systems, but also "in space"with new variants. Fortunately, many different methods and tools for variant-rich systems have been proposed over the last decades, especially in the field of software product line engineering. However, their level of evaluation varies significantly, threatening their relevance for practitioners and that of future research. Many tools have only been evaluated on ad hoc datasets, minimal examples, or unrealistic and limited evolution scenarios, missing large parts of the actual evolution lifecycle of variant-rich systems. Our long-term goal is to provide benchmarks to increase the maturity of evaluation of methods and tools for evolving variant-rich systems. However, providing manually curated and sufficiently detailed benchmarks that cover the whole evolution lifecycle of variant-rich systems is challenging. We present the framework vpbench, which simulates the evolution of a variant-rich system and thereby generates an evolution enriched with metadata explaining the evolution. The generated benchmarks, i.e., the evolution histories and metadata, can serve as ground truth to check the results of tools applied on it. We formalize the claims we make about the generator and the generated benchmarks as requirements. The design of vpbench comprises modular generators and evolution operators that automatically evolve real codebases. We implement simple and advanced evolution operators-e.g., relying on code transplantation to incorporate features from real projects. We demonstrate how vpbench addresses its claimed requirements, also considering multiple degrees of realism, extensibility and language-independence of the generated benchmarks.(c) 2023 Elsevier Inc. All rights reserved.
  •  
17.
  • Diniz Caldas, Ricardo, 1994, et al. (författare)
  • Towards Mapping Control Theory and Software Engineering Properties using Specification Patterns
  • 2021
  • Ingår i: 2021 IEEE International Conference on Autonomic Computing and Self-Organizing Systems Companion (ACSOS-C). - Washington DC, United States : IEEE. - 9781665443937
  • Konferensbidrag (refereegranskat)abstract
    • A traditional approach to realize self-adaptation in software engineering (SE) is by means of feedback loops. The goals of the system can be specified as formal properties that are verified against models of the system. On the other hand, control theory (CT) provides a well-established foundation for designing feedback loop systems and providing guarantees for essential properties, such as stability, settling time, and steady state error. Currently, it is an open question whether and how traditional SE approaches to self-adaptation consider properties from CT. Answering this question is challenging given the principle differences in representing properties in both fields. In this paper, we take a first step to answer this question. We follow a bottom up approach where we specify a control design (in Simulink) for a case inspired by Scuderia Ferrari (F1) and provide evidence for stability and safety. The design is then transferred into code (in C) that is further optimized. Next, we define properties that enable verifying whether the control properties still hold at code level. Then, we consolidate the solution by mapping the properties in both worlds using specification patterns as common language and we verify the correctness of this mapping. The mapping offers a reusable artifact to solve similar problems. Finally, we outline opportunities for future work, particularly to refine and extend the mapping and investigate how it can improve the engineering of self-adaptive systems for both SE and CT engineers.
  •  
18.
  • Entekhabi, Sina, 1989, et al. (författare)
  • Visualization of feature locations with the tool FeatureDashboard
  • 2019
  • Ingår i: ACM International Conference Proceeding Series. - New York, NY, USA : ACM. ; B
  • Konferensbidrag (refereegranskat)abstract
    • Modern development processes and issue trackers often use the notion of features to manage a software system. Features allow communicating system characteristics across stakeholders and keeping an overview understanding - especially important for systems that exist in many different variants. However, maintaining, evolving or reusing features (e.g., propagating across variants, or integrating into a platform) requires knowing their locations to prevent extensive feature-location recovery. We advocate the use of embedded annotations, added directly into software assets by the developers during development. To support this process and provide immediate benefits to developers when using such annotations, we present the open-source tool FeatureDashboard. It extracts and visualizes features and their locations using different views and metrics. As such, it encourages developers recording features and their locations early, to prevent feature identification and location efforts, as well as it supports system comprehension.
  •  
19.
  • García Gonzalo, Sergio, 1989, et al. (författare)
  • An Architecture for Decentralized, Collaborative, and Autonomous Robots
  • 2018
  • Ingår i: Proceedings - 2018 IEEE 15th International Conference on Software Architecture, ICSA 2018. ; , s. 75-84
  • Konferensbidrag (refereegranskat)abstract
    • Robotic applications are typically realized using ad hoc and domain-specific solutions, which challenges the engineering and cross-project reuse of such applications. Especially in complex scenarios, where self-adaptive robots collaborate among themselves or with humans, the effective and systematic engineering of such applications is becoming increasingly important. Such scenarios require decentralized software architectures that foster fault-tolerant ways of managing large teams of (possibly) heterogeneous robots. To the best of our knowledge, no existing architecture for robot applications supports decentralized and self-adaptive collaboration. To address this gap, we conducted a design science study with 21 practitioners and experts in the field of robotics to develop an architecture fulfilling these requirements through several iterations. We present SERA, an architecture for robot applications that supports human-robot collaboration, as well as adaptation and coordination of single- and multi-robot systems in a decentralized fashion. SERA is based on layers that contain components that manage the adaptation at different levels of abstraction and communicate through well-defined interfaces. We successfully validated SERA by considering a set of real scenarios, by both using simulators and real robots, by involving robotic experts, and by benchmarking it with state-of-the-art solutions.
  •  
20.
  • García Gonzalo, Sergio, 1989, et al. (författare)
  • Robotics Software Engineering: A Perspective from the Service Robotics Domain (Summary)
  • 2020
  • Ingår i: Lecture Notes in Informatics. - 1617-5468. ; P-310, s. 41-42
  • Konferensbidrag (refereegranskat)abstract
    • We present our paper published in the proceedings of the ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering 2020. Robots that support humans by performing useful tasks (a.k.a., service robots) are booming worldwide. In contrast to industrial robots, the development of service robots comes with severe software engineering challenges, since they require high levels of robustness and autonomy to operate in highly heterogeneous environments. As a domain with critical safety implications, service robotics faces a need for sound software development practices. In this paper, we present the first large-scale empirical study to assess the state of the art and practice of robotics software engineering. We conducted 18 semi-structured interviews with industrial practitioners working in 15 companies from 9 different countries and a survey with 156 respondents (from 26 countries) from the robotics domain. Our results provide a comprehensive picture of (i) the practices applied by robotics industrial and academic practitioners, including processes, paradigms, languages, tools, frameworks, and reuse practices, (ii) the distinguishing characteristics of robotics software engineering, and (iii) recurrent challenges usually faced, together with adopted solutions. The paper concludes by discussing observations, derived hypotheses, and proposed actions for researchers and practitioners.
  •  
21.
  • García Gonzalo, Sergio, 1989, et al. (författare)
  • Software variability in service robotics
  • 2023
  • Ingår i: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1573-7616 .- 1382-3256. ; 28:2
  • Tidskriftsartikel (refereegranskat)abstract
    • Robots artificially replicate human capabilities thanks to their software, the main embodiment of intelligence. However, engineering robotics software has become increasingly challenging. Developers need expertise from different disciplines as well as they are faced with heterogeneous hardware and uncertain operating environments. To this end, the software needs to be variable—to customize robots for different customers, hardware, and operating environments. However, variability adds substantial complexity and needs to be managed—yet, ad hoc practices prevail in the robotics domain, challenging effective software reuse, maintenance, and evolution. To improve the situation, we need to enhance our empirical understanding of variability in robotics. We present a multiple-case study on software variability in the vibrant and challenging domain of service robotics. We investigated drivers, practices, methods, and challenges of variability from industrial companies building service robots. We analyzed the state-of-the-practice and the state-of-the-art—the former via an experience report and eleven interviews with two service robotics companies; the latter via a systematic literature review. We triangulated from these sources, reporting observations with actionable recommendations for researchers, tool providers, and practitioners. We formulated hypotheses trying to explain our observations, and also compared the state-of-the-art from the literature with the-state-of-the-practice we observed in our cases. We learned that the level of abstraction in robotics software needs to be raised for simplifying variability management and software integration, while keeping a sufficient level of customization to boost efficiency and effectiveness in their robots’ operation. Planning and realizing variability for specific requirements and implementing robust abstractions permit robotic applications to operate robustly in dynamic environments, which are often only partially known and controllable. With this aim, our companies use a number of mechanisms, some of them based on formalisms used to specify robotic behavior, such as finite-state machines and behavior trees. To foster software reuse, the service robotics domain will greatly benefit from having software components—completely decoupled from hardware—with harmonized and standardized interfaces, and organized in an ecosystem shared among various companies.
  •  
22.
  • García Gonzalo, Sergio, 1989, et al. (författare)
  • Variability modeling of service robots: Experiences and challenges
  • 2019
  • Ingår i: ACM International Conference Proceeding Series. - New York, NY, USA : ACM.
  • Konferensbidrag (refereegranskat)abstract
    • Sensing, planning, controlling, and reasoning, are human-like capabilities that can be articially replicated in an autonomous robot. Such a robot implements data structures and algorithms devised on a large spectrum of theories, from probability theory, mechanics, and control theory to ethology, economy, and cognitive sciences. Software plays a key role in the development of robotic systems, as it is the medium to embody intelligence in the machine. During the last years, however, software development is increasingly becoming the bottleneck of robotic systems engineering due to three factors: (a) the software development is mostly based on community efforts and it is not coordinated by key stakeholders; (b) robotic technologies are characterized by a high variability that makes reuse of software a challenging practice; and (c) robotics developers are usually not specically trained in software engineering. In this paper, we illustrate our experiences from EU, academic, and industrial projects in identifying, modeling, and managing variability in the domain of service robots. We hope to raise awareness for the specic variability challenges in robotics software engineering and to inspire other researchers to advance thiseld.
  •  
23.
  • Garcia, Sergio, et al. (författare)
  • High-level mission specification for multiple robots
  • 2019
  • Ingår i: SLE 2019: Proceedings of the 12th ACM SIGPLAN International Conference on Software Language Engineering. - New York, NY, USA : ACM.
  • Konferensbidrag (refereegranskat)abstract
    • Mobile robots are increasingly used in our everyday life to autonomously realize missions. A variety of languages has been proposed to support roboticists in the systematic development of robotic applications, ranging from logical languages with well-defined semantics to domain-specific languages with user-friendly syntax. The characteristics of both of them have distinct advantages, however, developing a language that combines those advantages remains an elusive task. We present PROMISE, a novel language that enables domain experts to specify missions on a high level of abstraction for teams of autonomous robots in a user-friendly way, while having well-defined semantics. Our ambition is to permit users to specify high-level goals instead of a series of specific actions the robots should perform. The language contains a set of atomic tasks that can be executed by robots and a set of operators that allow the composition of these tasks in complex missions. The language is supported by a standalone tool that permits mission specification through a textual and a graphical interface and that can be integrated within a variety of frameworks. We integrated PROMISE with a software platform providing functionalities such as motion control and planning. We conducted experiments to evaluate the correctness of the specification and execution of complex robotic missions with both simulators and real robots. We also conducted two user studies to assess the simplicity of PROMISE. The results show that PROMISE effectively supports users to specify missions for robots in a user-friendly manner.
  •  
24.
  • Garcia, Sergio, et al. (författare)
  • PROMISE: High-level mission specification for multiple robots
  • 2020
  • Ingår i: Proceedings - International Conference on Software Engineering. - New York, NY, USA : ACM. - 0270-5257.
  • Konferensbidrag (refereegranskat)abstract
    • Service robots, a type of robots that perform useful tasks for humans, are foreseen to be broadly used in the near future in both social and industrial scenarios. Those robots will be required to operate in dynamic environments, collaborating among them or with users. Specifying the list of requested tasks to be achieved by a robotic team is far from being trivial. Therefore, mission specification languages and tools need to be expressive enough to allow the specification of complex missions (e.g., detailing recovery actions), while being reachable by domain experts who might not be knowledgeable of programming languages. To support domain experts, we developed PROMISE, a Domain-Specific Language that allows mission specification for multiple robots in a user-friendly, yet rigorous manner. PROMISE is built as an Eclipse plugin that provides a textual and a graphical interface for mission specification. Our tool is in turn integrated into a software framework, which provides functionalities as: (1) automatic generation from specification, (2) sending of missions to the robotic team; and (3) interpretation and management of missions during execution time. PROMISE and its framework implementation have been validated through simulation and real-world experiments with four different robotic models. Video: https://youtu.be/RMtqwY2GOlQ
  •  
25.
  • Garcia, Sergio, et al. (författare)
  • Robotics Software Engineering: A Perspective from the Service Robotics Domain
  • 2020
  • Ingår i: Proceedings of the 28th ACM Joint European Soft- ware Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE ’20). - New York, NY, USA : ACM. - 9781450370431
  • Konferensbidrag (refereegranskat)abstract
    • Robots that support humans by performing useful tasks (a.k.a., service robots) are booming worldwide. In contrast to industrial robots, the development of service robots comes with severe software engineering challenges, since they require high levels of robustness and autonomy to operate in highly heterogeneous environments. As a domain with critical safety implications, service robotics faces a need for sound software development practices. In this paper, we present the first large-scale empirical study to assess the state of the art and practice of robotics software engineering. We conducted 18 semi-structured interviews with industrial practitioners working in 15 companies from 9 different countries and a survey with 156 respondents from 26 countries from the robotics domain. Our results provide a comprehensive picture of (i) the practices applied by robotics industrial and academic practitioners, including processes, paradigms, languages, tools, frameworks, and reuse practices, (ii) the distinguishing characteristics of robotics software engineering, and (iii) recurrent challenges usually faced, together with adopted solutions. The paper concludes by discussing observations, derived hypotheses, and proposed actions for researchers and practitioners.
  •  
26.
  •  
27.
  • Ghzouli, Razan, 1991, et al. (författare)
  • Behavior Trees and State Machines in Robotics Applications
  • 2023
  • Ingår i: IEEE Transactions on Software Engineering. - 0098-5589 .- 1939-3520. ; 49:9, s. 4243-4267
  • Tidskriftsartikel (refereegranskat)abstract
    • Autonomous robots combine skills to form increasingly complex behaviors, called missions. While skills are often programmed at a relatively low abstraction level, their coordination is architecturally separated and often expressed in higher-level languages or frameworks. State machines have been the go-to language to model behavior for decades, but recently, behavior trees have gained attention among roboticists. Originally designed to model autonomous actors in computer games, behavior trees offer an extensible tree-based representation of missions and are claimed to support modular design and code reuse. Although several implementations of behavior trees are in use, little is known about their usage and scope in the real world. How do concepts offered by behavior trees relate to traditional languages, such as state machines? How are concepts in behavior trees and state machines used in actual applications? This paper is a study of the key language concepts in behavior trees as realized in domain-specific languages (DSLs), internal and external DSLs offered as libraries, and their use in open-source robotic applications supported by the Robot Operating System (ROS). We analyze behavior-tree DSLs and compare them to the standard language for behavior models in robotics: state machines. We identify DSLs for both behavior-modeling languages, and we analyze five in-depth. We mine open-source repositories for robotic applications that use the analyzed DSLs and analyze their usage. We identify similarities between behavior trees and state machines in terms of language design and the concepts offered to accommodate the needs of the robotics domain. We observed that the usage of behavior-tree DSLs in open-source projects is increasing rapidly. We observed similar usage patterns at model structure and at code reuse in the behavior-tree and state-machine models within the mined open-source projects. We contribute all extracted models as a dataset, hoping to inspire the community to use and further develop behavior trees, associated tools, and analysis techniques.
  •  
28.
  • Ghzouli, Razan, 1991, et al. (författare)
  • Behavior Trees in Action: A study of Robotics Applications
  • 2020
  • Ingår i: SLE 2020: Proceedings of the 13th ACM SIGPLAN International Conference on Software Language Engineering. - New York, NY, USA : ACM. - 9781450381765 - 9781450381765 ; 16 November 2020, s. 196-209
  • Konferensbidrag (refereegranskat)abstract
    • Autonomous robots combine a variety of skills to form increasingly complex behaviors called missions. While the skills are often programmed at a relatively low level of abstraction, their coordination is architecturally separated and often expressed in higher-level languages or frameworks. Recently, the language of Behavior Trees gained attention among roboticists for this reason. Originally designed for computer games to model autonomous actors, Behavior Trees offer an extensible tree-based representation of missions. However, even though, several implementations of the language are in use, little is known about its usage and scope in the real world. How do behavior trees relate to traditional languages for describing behavior? How are behavior tree concepts used in applications? What are the benefits of using them? We present a study of the key language concepts in Behavior Trees and their use in real-world robotic applications. We identify behavior tree languages and compare their semantics to the most well-known behavior modeling languages: state and activity diagrams. We mine open source repositories for robotics applications that use the language and analyze this usage. We find that Behavior Trees are a pragmatic language, not fully specified, allowing projects to extend it even for just one model. Behavior trees clearly resemble the models-at-runtime paradigm. We contribute a dataset of real-world behavior models, hoping to inspire the community to use and further develop this language, associated tools, and analysis techniques.
  •  
29.
  •  
30.
  • Idowu, Samuel, 1985, et al. (författare)
  • A Large-Scale Study of ML-Related Python Projects
  • 2024
  • Ingår i: Proceedings of the ACM Symposium on Applied Computing. ; , s. 1272-1281
  • Konferensbidrag (refereegranskat)abstract
    • The rise of machine learning (ML) for solving current and future problems increased the production of ML-enabled software systems. Unfortunately, standardized tool chains for developing, employing, and maintaining such projects are not yet mature, which can mainly be attributed to a lack of understanding of the properties of ML-enabled software. For instance, it is still unclear how to manage and evolve ML-specific assets together with other software-engineering assets. In particular, ML-specific tools and processes, such as those for managing ML experiments, are often perceived as incompatible with practitioners' software engineering tools and processes. To design new tools for developing ML-enabled software, it is crucial to understand the properties and current problems of developing these projects by eliciting empirical data from real projects, including the evolution of the different assets involved. Moreover, while studies in this direction have recently been conducted, identifying certain types of ML-enabled projects (e.g., experiments, libraries and software systems) remains a challenge for researchers. We present a large-scale study of over 31,066 ML projects found on GitHub, with an emphasis on their development stages and evolution. Our contributions include a dataset, together with empirical data providing an overview of the existing project types and analysis of the projects' properties and characteristics, especially regarding the implementation of different ML development stages and their evolution. We believe that our results support researchers, practitioners, and tool builders conduct follow-up studies and especially build novel tools for managing ML projects, ideally unified with traditional software-engineering tools.
  •  
31.
  • Idowu, Samuel, 1985, et al. (författare)
  • Asset Management in Machine Learning: A Survey
  • 2021
  • Ingår i: Proceedings - International Conference on Software Engineering. - 0270-5257.
  • Konferensbidrag (refereegranskat)abstract
    • Machine Learning (ML) techniques are becoming essential components of many software systems today, causing an increasing need to adapt traditional software engineering practices and tools to the development of ML-based software systems. This need is especially pronounced due to the challenges associated with the large-scale development and deployment of ML systems. Among the most commonly reported challenges during the development, production, and operation of ML-based systems are experiment management, dependency management, monitoring, and logging of ML assets. In recent years, we have seen several efforts to address these challenges as witnessed by an increasing number of tools for tracking and managing ML experiments and their assets. To facilitate research and practice on engineering intelligent systems, it is essential to understand the nature of the current tool support for managing ML assets. What kind of support is provided? What asset types are tracked? What operations are offered to users for managing those assets? We discuss and position ML asset management as an important discipline that provides methods and tools for ML assets as structures and the ML development activities as their operations. We present a feature-based survey of 17 tools with ML asset management support identified in a systematic search. We overview these tools' features for managing the different types of assets used for engineering ML-based systems and performing experiments. We found that most of the asset management support depends on traditional version control systems, while only a few tools support an asset granularity level that differentiates between important ML assets, such as datasets and models.
  •  
32.
  • Idowu, Samuel, 1985, et al. (författare)
  • Asset Management in Machine Learning: State-of-research and State-of-practice
  • 2023
  • Ingår i: Acm Computing Surveys. - : Association for Computing Machinery (ACM). - 0360-0300 .- 1557-7341. ; 55:7
  • Tidskriftsartikel (refereegranskat)abstract
    • Machine learning components are essential for today's software systems, causing a need to adapt traditional software engineering practices when developing machine-learning-based systems. This need is pronounced due to many development-related challenges of machine learning components such as asset, experiment, and dependency management. Recently, many asset management tools addressing these challenges have become available. It is essential to understand the support such tools offer to facilitate research and practice on building new management tools with native supports for machine learning and software engineering assets. This article positions machine learning asset management as a discipline that provides improved methods and tools for performing operations on machine learning assets. We present a feature-based survey of 18 state-of-practice and 12 state-of-research tools supporting machine-learning assetmanagement. We overview their features for managing the types of assets used in machine learning experiments. Most state-of-research tools focus on tracking, exploring, and retrieving assets to address development concerns such as reproducibility, while the state-of-practice tools also offer collaboration and workflow-execution-related operations. In addition, assets are primarily tracked intrusively from the source code through APIs and managed via web dashboards or command-line interfaces (CLIs). We identify asynchronous collaboration and asset reusability as directions for new tools and techniques.
  •  
33.
  •  
34.
  • Idowu, Samuel, 1985, et al. (författare)
  • EMMM: A Unified Meta-Model for Tracking Machine Learning Experiments
  • 2022
  • Ingår i: Proceedings - 48th Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2022. ; , s. 48-55
  • Konferensbidrag (refereegranskat)abstract
    • Traditional software engineering tools for managing assets—specifically, version control systems—are inadequate to manage the variety of asset types used in machine-learning model development experiments. Two possible paths to improve the management of machine learning assets include 1) Adopting dedicated machine-learning experiment management tools, which are gaining popularity for supporting concerns such as versioning, traceability, auditability, collaboration, and reproducibility; 2) Developing new and improved version control tools with support for domain-specific operations tailored to machine learning assets. As a contribution to improving asset management on both paths, this work presents Experiment Management Meta-Model (EMMM), a meta-model that unifies the conceptual structures and relationships extracted from systematically selected machine-learning experiment management tools. We explain the metamodel’s concepts and relationships and evaluate it using real experiment data. The proposed meta-model is based on the Eclipse Modeling Framework (EMF) with its meta-modeling language, Ecore, to encode model structures. Our meta-model can be used as a concrete blueprint for practitioners and researchers to improve existing tools and develop new tools with native support for machine-learning-specific assets and operations.
  •  
35.
  • Idowu, Samuel, 1985, et al. (författare)
  • Machine learning experiment management tools: a mixed-methods empirical study
  • 2024
  • Ingår i: Empirical Software Engineering. - 1573-7616 .- 1382-3256. ; 29:4
  • Tidskriftsartikel (refereegranskat)abstract
    • Machine Learning (ML) experiment management tools support ML practitioners and software engineers when building intelligent software systems. By managing large numbers of ML experiments comprising many different ML assets, they not only facilitate engineering ML models and ML-enabled systems, but also managing their evolution—for instance, tracing system behavior to concrete experiments when the model performance drifts. However, while ML experiment management tools have become increasingly popular, little is known about their effectiveness in practice, as well as their actual benefits and challenges. We present a mixed-methods empirical study of experiment management tools and the support they provide to users. First, our survey of 81 ML practitioners sought to determine the benefits and challenges of ML experiment management and of the existing tool landscape. Second, a controlled experiment with 15 student developers investigated the effectiveness of ML experiment management tools. We learned that 70% of our survey respondents perform ML experiments using specialized tools, while out of those who do not use such tools, 52% are unaware of experiment management tools or of their benefits. The controlled experiment showed that experiment management tools offer valuable support to users to systematically track and retrieve ML assets. Using ML experiment management tools reduced error rates and increased completion rates. By presenting a user’s perspective on experiment management tools, and the first controlled experiment in this area, we hope that our results foster the adoption of these tools in practice, as well as they direct tool builders and researchers to improve the tool landscape overall.
  •  
36.
  •  
37.
  • Krueger, Jacob, et al. (författare)
  • Where is my feature and what is it about? A case study on recovering feature facets
  • 2019
  • Ingår i: Journal of Systems and Software. - : Elsevier BV. - 0164-1212. ; 152, s. 239-253
  • Tidskriftsartikel (refereegranskat)abstract
    • Developers commonly use features to define, manage, and communicate functionalities of a system. Unfortunately, the locations of features in code and other characteristics (feature facets), relevant for evolution and maintenance, are often poorly documented. Since developers change, and knowledge fades with time, such information often needs to be recovered. Modern projects boast a richness of information sources, such as pull requests, release logs, and otherwise specified domain knowledge. However, it is largely unknown from what sources the features, their locations, and their facets can be recovered. We present an exploratory study on identifying such information in two popular, variant-rich, and long-living systems: The 3D-printer firmware Marlin and the Android application Bitcoin-wallet. Besides the available information sources, we also investigated the projects' communities, communications, and development cultures. Our results show that a multitude of information sources (e.g., commit messages and pull requests) is helpful to recover features, locations, and facets to different extents. Pull requests were the most valuable source to recover facets, followed by commit messages and the issue tracker. As many of the studied information sources are, so far, rarely exploited in techniques for recovering features and their facets, we hope to inspire researchers and tool builders with our results. (C) 2019 Elsevier Inc. All rights reserved.
  •  
38.
  • Krüger, Jacob, et al. (författare)
  • Activities and costs of re-engineering cloned variants into an integrated platform
  • 2020
  • Ingår i: ACM International Conference Proceeding Series. - New York, NY, USA : ACM.
  • Konferensbidrag (refereegranskat)abstract
    • Many software systems need to exist in multiple variants. Organizations typically develop variants using clone & own-copying and adapting systems towards new requirements. However, while clone & own is a simple and readily available strategy, it does not scale with the number of variants, and then requires a costly re-engineering of the cloned variants into a configurable software platform (a.k.a., software product line). Ideally, organizations could rely on decision models or at least on substantial empirical data to assess the costs and benefits of such a re-engineering. Unfortunately, despite decades of research on product lines and platforms, such data is scarce, not least because obtaining it from industrial re-engineering efforts is challenging. We address this gap with a study on re-engineering two cases of cloned variants of open-source Android and Java games. Student developers re-engineered the clones into software product lines, logging their activities and costs. They performed the types of activities typically associated with re-engineering, but the activities were intertwined and done iteratively. The costs were relatively similar among both cases, but the used variability mechanism had a substantial impact. Interestingly, beyond a common diffing tool, no dedicated re-engineering tool was particularly useful. We hope that our results support researchers working on re-engineering techniques and decision models, as well as practitioners trying to assess the costs and activities involved in re-engineering a software platform.
  •  
39.
  • Kruger, J., et al. (författare)
  • Effects of Explicit Feature Traceability on Program Comprehension
  • 2019
  • Ingår i: ESEC/FSE 2019. Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. - New York, NY, USA : IEEE. - 9781450355728
  • Konferensbidrag (refereegranskat)abstract
    • Developers spend a substantial amount of their time with program comprehension. To improve their comprehension and refresh their memory, developers need to communicate with other developers, read the documentation, and analyze the source code. Many studies show that developers focus primarily on the source code and that small improvements can have a strong impact. As such, it is crucial to bring the code itself into a more comprehensible form. A particular technique for this purpose are explicit feature traces to easily identify a program's functionalities. To improve our empirical understanding about the effects of feature traces, we report an online experiment with 49 professional software developers. We studied the impact of explicit feature traces, namely annotations and decomposition, on program comprehension and compared them to the same code without traces. Besides this experiment, we also asked our participants about their opinions in order to combine quantitative and qualitative data. Our results indicate that, as opposed to purely object-oriented code: (1) annotations can have positive effects on program comprehension; (2) decomposition can have a negative impact on bug localization; and (3) our participants perceive both techniques as beneficial. Moreover, none of the three code versions yields significant improvements on task completion time. Overall, our results indicate that lightweight traceability, such as using annotations, provides immediate benefits to developers during software development and maintenance without extensive training or tooling; and can improve current industrial practices that rely on heavyweight traceability tools (e.g., DOORS) and retroactive fulfillment of standards (e.g., ISO-26262, DO-178B).
  •  
40.
  • Krüger, Jacob, et al. (författare)
  • Promote-pl: a round-trip engineering process model for adopting and evolving product lines
  • 2020
  • Ingår i: ACM International Conference Proceeding Series. - New York, NY, USA : ACM. ; A, s. 1-12
  • Konferensbidrag (refereegranskat)abstract
    • Process models for software product-line engineering focus on proactive adoption scenarios - -that is, building product-line platforms from scratch. They comprise the two phases domain engineering (building a product-line platform) and application engineering (building individual variants), each of which defines various development activities. Established more than two decades ago, these process models are still the de-facto standard for steering the engineering of platforms and variants. However, observations from industrial and open-source practice indicate that the separation between domain and application engineering, with their respective activities, does not fully reflect reality. For instance, organizations rarely build platforms from scratch, but start with developing individual variants that are re-engineered into a platform when the need arises. Organizations also appear to evolve platforms by evolving individual variants, and they use contemporary development activities aligned with technical advances. Recognizing this discrepancy, we present an updated process model for engineering software product lines. We employ a method for constructing process theories, building on recent literature as well as our experiences with industrial partners to identify development activities and the orders in which these are performed. Based on these activities, we synthesize and discuss the new process model, called promote-pl. Also, we explain its relation to modern software-engineering practices, such as continuous integration, model-driven engineering, or simulation testing. We hope that our work offers contemporary guidance for product-line engineers developing and evolving platforms, and inspires researchers to build novel methods and tools aligned with current practice.
  •  
41.
  •  
42.
  •  
43.
  • Lillack, M., et al. (författare)
  • Intention-Based Integration of Software Variants
  • 2019
  • Ingår i: 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). - : IEEE. - 9781728108698 ; , s. 831-842
  • Bokkapitel (övrigt vetenskapligt/konstnärligt)abstract
    • Cloning is a simple way to create new variants of a system. While cheap at first, it increases maintenance cost in the long term. Eventually, the cloned variants need to be integrated into a configurable platform. Such an integration is challenging: it involves merging the usual code improvements between the variants, and also integrating the variable code (features) into the platform. Thus, variant integration differs from traditional software merging, which does not produce or organize configurable code, but creates a single system that cannot be configured into variants. In practice, variant integration requires fine-grained code edits, performed in an exploratory manner, in multiple iterations. Unfortunately, little tool support exists for integrating cloned variants. In this work, we show that fine-grained code edits needed for integration can be alleviated by a small set of integration intentions domain-specific actions declared over code snippets controlling the integration. Developers can interactively explore the integration space by declaring (or revoking) intentions on code elements. We contribute the intentions (e.g., 'keep functionality' or 'keep as a configurable feature') and the IDE tool INCLINE, which implements the intentions and live editable views that visualize the integration process and allow declaring intentions producing a configurable integrated platform. In a series of experiments, we evaluated the completeness of the proposed intentions, the correctness and performance of INCLINE, and the benefits of using intentions for variant integration. The experiments show that INCLINE can handle complex integration tasks, that views help to navigate the code, and that it consistently reduces mistakes made by developers during variant integration.
  •  
44.
  • Lindohf, R., et al. (författare)
  • Software product-line evaluation in the large
  • 2021
  • Ingår i: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; 26:2
  • Tidskriftsartikel (refereegranskat)abstract
    • Software product-line engineering is arguably one of the most successful methods for establishing large portfolios of software variants in an application domain. However, despite the benefits, establishing a product line requires substantial upfront investments into a software platform with a proper product-line architecture, into new software-engineering processes (domain engineering and application engineering), into business strategies with commercially successful product-line visions and financial planning, as well as into re-organization of development teams. Moreover, establishing a full-fledged product line is not always possible or desired, and thus organizations often adopt product-line engineering only to an extent that deemed necessary or was possible. However, understanding the current state of adoption, namely, the maturity or performance of product-line engineering in an organization, is challenging, while being crucial to steer investments. To this end, several measurement methods have been proposed in the literature, with the most prominent one being the Family Evaluation Framework (FEF), introduced almost two decades ago. Unfortunately, applying it is not straightforward, and the benefits of using it have not been assessed so far. We present an experience report of applying the FEF to nine medium- to large-scale product lines in the avionics domain. We discuss how we tailored and executed the FEF, together with the relevant adaptations and extensions we needed to perform. Specifically, we elicited the data for the FEF assessment with 27 interviews over a period of 11 months. We discuss experiences and assess the benefits of using the FEF, aiming at helping other organizations assessing their practices for engineering their portfolios of software variants.
  •  
45.
  • Linsbauer, L., et al. (författare)
  • A Classification of Variation Control Systems
  • 2017
  • Ingår i: GPCE 2017 Proceedings of the 16th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences. - New York, NY, USA : ACM. - 0362-1340. - 9781450355247
  • Konferensbidrag (refereegranskat)abstract
    • Version control systems are an integral part of today's software and systems development processes. They facilitate the management of revisions (sequential versions) and variants (concurrent versions) of a system under development and enable collaboration between developers. Revisions are commonly maintained either per file or for the whole system. Variants are supported via branching or forking mechanisms that conceptually clone the whole system under development. It is known that such cloning practices come with disadvantages. In fact, while short-lived branches for isolated development of new functionality (a.k.a. feature branches) are well supported, dealing with long-term and fine-grained system variants currently requires employing additional mechanisms, such as preprocessors, build systems or custom configuration tools. Interestingly, the literature describes a number of variation control systems, which provide a richer set of capabilities for handling fine-grained system variants compared to the version control systems widely used today. In this paper we present a classification and comparison of selected variation control systems to get an understanding of their capabilities and the advantages they can offer. We discuss problems of variation control systems, which may explain their comparably low popularity. We also propose research activities we regard as important to change this situation.
  •  
46.
  • Linsbauer, Lukas, et al. (författare)
  • Concepts of variation control systems
  • 2021
  • Ingår i: Journal of Systems and Software. - : Elsevier BV. - 0164-1212. ; 171
  • Tidskriftsartikel (refereegranskat)abstract
    • Version control systems are an integral part of today's software engineering. They facilitate the collaborative management of revisions (sequential versions) and variants (concurrent versions) of software systems under development. Typical version control systems maintain revisions of files and variants of whole software systems. Variants are supported via branching or forking mechanisms that conceptually clone whole systems in a coarse-grained way. Unfortunately, such cloning leads to high maintenance efforts. To avoid these disadvantages and support fine-grained variation, developers need to employ custom configuration mechanisms, which leads to a misappropriation of tools and undesired context switches. Addressing this trade-off, a number of variation control systems has been conceived, providing a richer set of capabilities for handling variants. Variation control systems decompose a software system into finer-grained variable entities and offer high-level metaphors to automatically manage this variability. In this paper, we classify and compare variation control systems and illustrate their core concepts and characteristics. All investigated variation control systems offer an iterative (checkout–modify–commit) workflow, but there are essential differences affecting developers. We highlight challenges and discuss research perspectives for developing the next generation of version and variation control systems.
  •  
47.
  • Mahmood, Wardah, 1992, et al. (författare)
  • Causes of merge conflicts: A case study of elasticsearch
  • 2020
  • Ingår i: ACM International Conference Proceeding Series. - New York, NY, USA : ACM.
  • Konferensbidrag (refereegranskat)abstract
    • © 2020 Association for Computing Machinery. Software branching and merging allows collaborative development and creating software variants, commonly referred to as clone & own. While simple and cheap, a trade-off is the need to merge code and to resolve merge conflicts, which frequently occur in practice. When resolving conflicts, a key challenge for developer is to understand the changes that led to the conflict. While merge conflicts and their characteristics are reasonably well understood, that is not the case for the actual changes that cause them. We present a case study of the changes-on the code and on the project-level (e.g., feature addition, refactoring, feature improvement)-that lead to conflicts. We analyzed the development history of ElasticSearch, a large open-source project that heavily relies on branching (forking) and merging. We inspected 40 merge conflicts in detail, sampled from 534 conflicts not resolvable by a semi-structured merge tool. On a code (structural) level, we classified the semantics of changes made. On a project-level, we categorized the decisions that motivated these changes. We contribute a categorization of code- and project-level changes and a detailed dataset of 40 conflict resolutions with a description of both levels of changes. Similar to prior studies, most of our conflicts are also small; while our categorization of code-level changes surprisingly differs from that of prior work. Refactoring, feature additions and feature enhancements are the most common causes of merge conflicts, most of which could potentially be avoided with better development tooling.
  •  
48.
  • Mahmood, Wardah, 1992, et al. (författare)
  • Effects of variability in models: a family of experiments
  • 2022
  • Ingår i: Empirical Software Engineering. - : Springer Science and Business Media LLC. - 1382-3256 .- 1573-7616. ; 27:3
  • Tidskriftsartikel (refereegranskat)abstract
    • The ever-growing need for customization creates a need to maintain software systems in many different variants. To avoid having to maintain different copies of the same model, developers of modeling languages and tools have recently started to provide implementation techniques for such variant-rich systems, notably variability mechanisms, which support implementing the differences between model variants. Available mechanisms either follow the annotative or the compositional paradigm, each of which have dedicated benefits and drawbacks. Currently, language and tool designers select the used variability mechanism often solely based on intuition. A better empirical understanding of the comprehension of variability mechanisms would help them in improving support for effective modeling. In this article, we present an empirical assessment of annotative and compositional variability mechanisms for three popular types of models. We report and discuss findings from a family of three experiments with 164 participants in total, in which we studied the impact of different variability mechanisms during model comprehension tasks. We experimented with three model types commonly found in modeling languages: class diagrams, state machine diagrams, and activity diagrams. We find that, in two out of three experiments, annotative technique lead to better developer performance. Use of the compositional mechanism correlated with impaired performance. For all three considered tasks, the annotative mechanism was preferred over the compositional one in all experiments. We present actionable recommendations concerning support of flexible, tasks-specific solutions, and the transfer of established best practices from the code domain to models.
  •  
49.
  • Mahmood, Wardah, 1992, et al. (författare)
  • Seamless Variability Management with the Virtual Platform
  • 2021
  • Ingår i: Proceedings - International Conference on Software Engineering. - 0270-5257.
  • Konferensbidrag (refereegranskat)abstract
    • Customization is a general trend in software engineering, demanding systems that support variable stakeholder requirements. Two opposing strategies are commonly used to create variants: software clone&own and software configuration with an integrated platform. Organizations often start with the former, which is cheap, agile, and supports quick innovation, but does not scale. The latter scales by establishing an integrated platform that shares software assets between variants, but requires high up-front investments or risky migration processes. So, could we have a method that allows an easy transition or even combine the benefits of both strategies? We propose a method and tool that supports a truly incremental development of variant rich systems, exploiting a spectrum between both opposing strategies. We design, formalize, and prototype the variability management framework virtual platform . It bridges clone&own and platform-oriented development. Relying on programming language independent conceptual structures representing software assets, it offers operators for engineering and evolving a system, comprising: traditional, asset-oriented operators and novel, feature-oriented operators for incrementally adopting concepts of an integrated platform. The operators record meta-data that is exploited by other operators to support the transition. Among others, they eliminate expensive feature-location effort or the need to trace clones. Our evaluation simulates the evolution of a real-world, clone-based system, measuring its costs and benefits.
  •  
50.
  • Martinson, Johan, et al. (författare)
  • HAnS: IDE-based editing support for embedded feature annotations
  • 2021
  • Ingår i: ACM International Conference Proceeding Series. - New York, NY, USA : ACM. ; Part F171625-B, s. 28-31
  • Konferensbidrag (refereegranskat)abstract
    • When developers maintain or evolve software, they often need to know the locations of features. This proves challenging when the feature locations are not documented, when the code was written by different developers who may have left the organization, or when the developer's memory of the implementation has faded. Automated feature location techniques are hard to adopt in practice, especially since they boast too many false positives. To address these challenges, embedded feature annotations have been proposed to allow developers to trace features in code during development with minimal effort. However, tool support is needed for developers to effectively record and use these annotations. We propose HAnS as a tool to meet this need; it is implemented as an IntelliJ IDE plugin to support developers seamlessly record feature locations while they write their code. HAnS supports developers when mapping features to software assets, such as files and code fragments, with code completion and syntax highlighting. It also provides functionality to browse feature definitions and locations, as well as refactor features. A demo video is available at https://youtu.be/cx_-ZshHLgA.
  •  
Skapa referenser, mejla, bekava och länka
  • Resultat 1-50 av 76
Typ av publikation
konferensbidrag (52)
tidskriftsartikel (19)
bokkapitel (4)
licentiatavhandling (1)
Typ av innehåll
refereegranskat (71)
övrigt vetenskapligt/konstnärligt (5)
Författare/redaktör
Berger, Thorsten, 19 ... (75)
Strüber, Daniel, 198 ... (13)
Mukelabai, Mukelabai ... (10)
Pelliccione, Patrizi ... (8)
Mahmood, Wardah, 199 ... (8)
Pelliccione, Patrizi ... (7)
visa fler...
Krüger, Jacob (7)
Idowu, Samuel, 1985 (7)
García Gonzalo, Serg ... (6)
Steghöfer, Jan-Phili ... (5)
Menghi, Claudio, 198 ... (5)
Brugali, Davide (5)
Hebig, Regina (4)
Ghzouli, Razan, 1991 (4)
Garcia, Sergio (4)
Wąsowski, Andrzej (4)
Swaib, Dragule, 1980 (4)
Czarnecki, Krzysztof (3)
Di Fava, Alessandro (3)
Kruger, J (3)
Queiroz, Rodrigo (3)
Andam, Berima, 1986 (2)
Chaudron, Michel, 19 ... (2)
Anjorin, Anthony, 19 ... (2)
Diniz Caldas, Ricard ... (2)
Peldszus, Sven (2)
Behringer, Benjamin (2)
Palz, Jochen (2)
Bergel, Alexandre (2)
Shen, Hui (2)
Voelter, Markus (2)
Menghi, C. (2)
Johnsen, Einar Broch (2)
Businge, J. (2)
Openja, M. (2)
Nadi, S. (2)
Ieee,, Ieee, (2)
Borba, Paulo (2)
Moisakis, Joao (2)
Seidl, Christoph (2)
Krueger, Jacob (2)
Strüber, D. (2)
Gu, Wanzi (2)
Stanciulescu, S. (2)
Linsbauer, Lukas (2)
Lämmel, Ralf (2)
Tsigkanos, C. (2)
Nešić, Damir, 1988- (2)
Apel, Sven (2)
Queiroz, R. (2)
visa färre...
Lärosäte
Göteborgs universitet (57)
Chalmers tekniska högskola (41)
Kungliga Tekniska Högskolan (2)
Mälardalens universitet (2)
Linnéuniversitetet (1)
Språk
Engelska (76)
Forskningsämne (UKÄ/SCB)
Naturvetenskap (74)
Teknik (32)
Samhällsvetenskap (8)

År

Kungliga biblioteket hanterar dina personuppgifter i enlighet med EU:s dataskyddsförordning (2018), GDPR. Läs mer om hur det funkar här.
Så här hanterar KB dina uppgifter vid användning av denna tjänst.

 
pil uppåt Stäng

Kopiera och spara länken för att återkomma till aktuell vy