Extractive Multi-Software Product Line Engineering
Developing variant-rich systems utilizing methods from software product-line engineering (SPLE) has become favored, as it offers strategies for systematic reuse of implementation artifacts across variants and helps handle the complexity of variant-rich software systems. In a software product line (SPL), software variants are developed using shared and reusable implementation artifacts, reducing the time-to-market and decreasing development and maintenance effort when developing variant-rich software systems. In practice, however, unstructured reuse strategies such as copy, paste, and modify, also known as clone-and-own, are frequently used to create new variants and features. Most developers in companies perceive cloning as a favorable and natural approach for reuse Research proposes migrating variants into an SPL to reduce the maintenance and evolution effort and transfer clone-and-own variants from unstructured into systematic reuse. However, modern variant-rich systems outgrow the scope of conventional SPLs. In order to reduce the complexity of systems and make it easier to plan, build, and test, modern In this thesis, we propose the extractive multi-software product line engineering (EMSPLE) process as a solution to the problem of extracting an MSPL from clone-and-own variants. As industrial software variants are created using different implementation artifacts such as source code, build files, or documentation, the process is designed to adapt to different implementation artifacts. The EMSPLE process is fully customizable to include the domain knowledge of the developers in the EMSPLE process. The EMSPLE process consists of identifying variability relations of implementation artifacts within and between variants, consolidating variability relations into a uniform representation, and recovering domain knowledge out of the uniform representation. The proposed EMSPLE process has been evaluated using publicly available case studies implemented in different programming languages. Using the EMSPLE process enables the migration of clone-and-own variants with cloned implementation artifacts within into a MSPL.
due to its simplicity and availability. In some cases, there is also a lack of awareness and knowledge about reuse, and developers often doubt alternative strategies. When clone-and-own is applied to address new or changing software requirements to fulfill new customer wishes or to react to changing regulatory guidelines, there will be many
variants after a while, inevitably leading to a loss of overview of implementation artifacts and relations between variants. Clone-and-own seems to be a straightforward technique for creating new variants and features in the short term. In the long term, it increases the maintenance and evolution effort and binds software developers, leading to high maintenance costs.
systems are divided into subsystems, also known as systems of systems (SoS). Using clone-and-own in SoS by copying and pasting subsystems adds a dimension of variability to the variants that out scopes traditional SPLs that are focused on systems. For the realization of systems with subsystems, a common solution is a multi software product line (MSPL). A MSPL is a set of interdependent SPLs often developed decentralized by multiple teams either to structure a complex SPL in manageable subsystems or to reuse other SPLs in bigger software projects. The result of cloning in a SoS is a set of duplicated variants with duplicated subsystems. However, to this point, no strategy exists that enables migrating a set of clone-and-own variants into an MSPL.
Die Entwicklung variantenreicher Systeme unter Verwendung von Methoden aus dem Software-Produktlinien-Engineering hat sich als beliebt erwiesen, da sie Strategien für die systematische Wiederverwendung von Implementierungsartefakten über Varianten hinweg bietet und dazu beiträgt, die Komplexität variantenreicher Softwaresysteme zu bewältigen. In einer Software-Produktlinie werden Softwarevarianten unter Verwendung gemeinsam genutzter und wiederverwendbarer Implementierungsartefakte entwickelt, was die Time-to-Market verkürzt und den Entwicklungsaufwand bei der Entwicklung variantenreicher Softwaresysteme verringert. In der Praxis jedoch, werden häufig unstrukturierte Wiederverwendungsstrategien wie Kopieren, Einfügen und Modifizieren, auch bekannt als Clone-and-Own, verwendet, um neue Varianten und Funktionen zu erstellen. Die meisten Entwickler in Unternehmen empfinden das Klonen als einen günstigen und natürlichen Ansatz zur Wiederverwendung aufgrund seiner Einfachheit und Verfügbarkeit. In einigen Fällen besteht auch ein Mangel an Bewusstsein und Wissen über Wiederverwendung, und Entwickler zweifeln oft an alternativen Strategien. Wenn Clone-and-Own angewendet wird, um neue oder sich ändernde Softwareanforderungen zu erfüllen, um neuen Kundenwünschen gerecht zu werden oder um auf sich ändernde regulatorische Vorgaben zu reagieren, entstehen im Laufe der Zeit viele Varianten, die zwangsläufig zu einem Verlust des Überblicks über Implementierungsartefakte Forschung schlägt vor, Varianten in eine Software-Produktlinie zu migrieren, um den Wartungs- und Entwicklungsbedarf zu reduzieren und Clone-and-Own-Varianten von unstrukturierter in systematische Wiederverwendung zu überführen. Moderne, variantenreiche Systeme übersteigen jedoch den Rahmen herkömmlicher Software-Produktlinien. Um die Komplexität von Systemen zu reduzieren und das Planen, Bauen und Testen zu vereinfachen, werden moderne Systeme in Teilsysteme aufgeteilt, die auch als Systeme von Systemen bekannt sind. Die Verwendung von Clone-and-Own in System von Systemen durch Kopieren und Einfügen von Teilsystemen fügt den Varianten eine Variabilitätsdimension hinzu, die traditionelle Software-Produktlinie überschreitet, die sich nur auf Systeme konzentrieren. Für die Realisierung von Systemen mit Teilsystemen ist eine Multi-Software-Produktlinie eine übliche Lösung. Eine Multi-Software-Produktlinie ist eine Reihe von voneinander abhängigen Software-Produktlinien, die oft dezentral von mehreren Teams entwickelt werden, entweder um eine komplexe Software-Produktlinie in überschaubare Teilsysteme zu strukturieren oder um andere Software-Produktlinien in größeren Softwareprojekten wiederzuverwenden. Das Ergebnis des Klonens in einem System von Systemen ist eine Reihe von duplizierten Varianten mit duplizierten Teilsystemen. Bisher existiert jedoch keine Strategie, die es ermöglicht, eine Reihe von Clone-and-Own-Varianten in eine Multi-Software-Produktlinie zu migrieren. In dieser Arbeit schlagen wir den Extraktiven Multi-Software-Produktlinie-Engineering Prozess (EMSPLE) als Lösung für das Problem vor, eine Multi-Software-Produktlinie aus Clone-and-Own-Varianten zu extrahieren. Da industrielle Softwarevarianten unter Verwendung unterschiedlicher Implementierungsartefakte wie Quellcode, Build-Dateien oder Dokumentation erstellt werden, wurde der Prozess entwickelt, um sich an verschiedene Implementierungsartefakte
und Beziehungen zwischen Varianten führen. Clone-and-Own scheint eine einfache Technik zur Erstellung neuer Varianten und Funktionen auf kurze Sicht zu sein. Langfristig erhöht es jedoch den Wartungs- und Entwicklungsbedarf und bindet Softwareentwickler, was zu hohen Wartungskosten führt.
anzupassen. Der EMSPLE-Prozess ist vollständig anpassbar, um das Domänenwissen der Entwickler in den EMSPLE-Prozess einzubeziehen. Der EMSPLE-Prozess besteht darin, Variabilitätsbeziehungen von Implementierungsartefakten innerhalb und zwischen Varianten zu identifizieren, Variabilitätsbeziehungen in eine einheitliche Darstellung zu konsolidieren und Domänenwissen aus der einheitlichen Darstellung zu extrahieren. Der vorgeschlagene EMSPLE-Prozess wurde anhand von öffentlich verfügbaren Fallstudien implementiert in verschiedenen Programmiersprachen evaluiert. Die Verwendung des EMSPLE-Prozesses ermöglicht die Migration von Clone-and-Own Varianten mit geklonten Implementierungsartefakten in eine Multi-Software-Produktlinie.
Preview
Cite
Access Statistic
Rights
Use and reproduction:
