The Feature-Architecture Mapping Method for Feature-Oriented Development of Software Product Lines

Software Produktlinien sind die Antwort von Software Engineering auf die zu-nehmende Komplexität und kürzerenProdukteinführungszeiten von heutigen Softwaresystemen. Nichtsdestotrotz erfordern Software Produktlinien einefortgeschrittene Wartbarkeit und hohe Flexibilität. Das kann durch die angemessene Trennung der Belange erreicht werden.Merkmale stellen die Hauptbelange im Kontext von Software Produktlinien dar. Demzufolge sollte ein Merkmal idealerweise ingenau einer Architekturkomponente implementiert werden. In der Praxis ist das jedoch nicht immer machbar. Deshalb solltezumindest ein starkes Mapping zwischen Merkmalen und der Architektur bestehen. Die Methoden zur Entwicklung von SoftwareProduktlinien, die dem Stand der Technik entsprechen, führen zu bedeutender Verstreutheit und Vermischung von Merkmalen. Indieser Arbeit wird die Feature-Architecture Mapping (FArM) Methode entwickelt, um ein stärkeres Mapping zwischen Merkmalenund der Produktlinien-Architektur zu erzielen. Der Input für FArM besteht in einem initialen Merkmalmodell, das anhand einerMethode zur Domänenanalyse erstellt wurde. Dieses initiale Merkmalmodell wird einer Serie von Transformationen unterzogen.Die Transformationen streben danach, ein Gleichgewicht zwischen der Sichtweise von Kunden und Softwarearchitekteneinzustellen. Die Merkmalinteraktionen werden während der Transformationen ausdrücklich optimiert. Von jedem Merkmal destransformierten Merkmalmodells wird eine Architekturkomponente abgeleitet. Die Architekturkomponenten implementieren dieApplikationslogik der entsprechenden Merkmale. Die Kommunikation zwischen den Komponenten spiegelt die Interaktion zwischenden Merkmalen wider. Dieser Ansatz führt im Vergleich zu den Produktlinien-Entwicklungsmethoden des Stands der Technik zueinem stärkeren Mapping zwischen Merkmalen und der Architektur und zu einer höheren Variabilität auf Merkmalebene. DieseEigenschaften haben eine bessere Wartbarkeit und eine vereinfachte generative Produktinstanzierung zur Folge, was wiederumdie Flexibilität der Produktlinien steigert. FArM wurde durch ihre Anwendung in einigen Domänen evaluiert, z.B. in denDomänen von Mobiltelefonen und Integrierten Entwicklungsumgebungen (IDEs). Diese Arbeit wird FArM anhand einer Fallstudie inder Domäne von Künstlichen Neuronalen Netzwerken präsentieren.Software product lines are the answer of software engineering to the increasing complexity and shorter time-to-market ofcontemporary software systems. Nonetheless, software product lines demand for advanced maintainability and high flexibility.The latter can be achieved through the proper separation of concerns. Features pose the main concerns in the context ofsoftware product lines. Consequently, one feature should ideally be implemented into exactly one architectural component. Inpractice, this is not always feasible. Therefore, at least a strong mapping between features and the architecture mustexist. The state of the art product line development methodologies introduce significant scattering and tangling offeatures. In this work, the Feature-Architecture Mapping (FArM) method is developed, to provide a stronger mapping betweenfeatures and the product line architecture. FArM receives as input an initial feature model created by a domain analysismethod. The initial feature model undergoes a series of transformations. The transformations strive to achieve a balancebetween the customer and architectural perspectives. Feature interaction is explicitly optimized during the feature modeltransformations. For each feature of the transformed feature model, one architectural component is derived. Thearchitectural components implement the application logic of the respective features. The component communication reflectsthe feature interaction. This approach, compared to the state of the art product line methodologies, allows a strongerfeature-architecture mapping and for higher variability on the feature level. These attributes provide highermaintainability and an improved generative approach to product instantiation, which in turn enhances product lineflexibility. FArM has been evaluated through its application in a number of domains, e.g in the mobile phone domain and theIntegrated Development Environment (IDE) domain. This work will present FArM on the basis of a case study in the domain ofartificial Neural Networks

CSOM/PL: A Virtual Machine Product Line

CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Early aspects: aspect-oriented requirements engineering and architecture design

This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications

Crosscutting, what is and what is not? A Formal definition based on a Crosscutting Pattern

Crosscutting is usually described in terms of scattering and tangling. However, the distinction between these concepts is vague, which could lead to ambiguous statements. Sometimes, precise definitions are required, e.g. for the formal identification of crosscutting concerns. We propose a conceptual framework for formalizing these concepts based on a crosscutting pattern that shows the mapping between elements at two levels, e.g. concerns and representations of concerns. The definitions of the concepts are formalized in terms of linear algebra, and visualized with matrices and matrix operations. In this way, crosscutting can be clearly distinguished from scattering and tangling. Using linear algebra, we demonstrate that our definition generalizes other definitions of crosscutting as described by Masuhara & Kiczales [21] and Tonella and Ceccato [28]. The framework can be applied across several refinement levels assuring traceability of crosscutting concerns. Usability of the framework is illustrated by means of applying it to several areas such as change impact analysis, identification of crosscutting at early phases of software development and in the area of model driven software development

Using problem descriptions to represent variabilities for context-aware applications

This paper investigates the potential use of problem descriptions to represent and analyse variability in context-aware software products. By context-aware, we refer to recognition of changes in properties of external domains, which are recognised as affecting the behaviour of products. There are many reasons for changes in the operating environment, from fluctuating resources upon which the product relies, to different operating locations or the presence of objects. There is an increasing expectation for software intensivedevices to be context-aware which, in turn, adds further variability to problem description and analysis. However, we argue in this paper that the capture of contextual variability on current variability representations and analyses has yet to be explored. We illustrate the representation of this type of variability in a pilot study, and conclude with lessons learnt and an agenda for further work

Towards Product Lining Model-Driven Development Code Generators

A code generator systematically transforms compact models to detailed code. Today, code generation is regarded as an integral part of model-driven development (MDD). Despite its relevance, the development of code generators is an inherently complex task and common methodologies and architectures are lacking. Additionally, reuse and extension of existing code generators only exist on individual parts. A systematic development and reuse based on a code generator product line is still in its infancy. Thus, the aim of this paper is to identify the mechanism necessary for a code generator product line by (a) analyzing the common product line development approach and (b) mapping those to a code generator specific infrastructure. As a first step towards realizing a code generator product line infrastructure, we present a component-based implementation approach based on ideas of variability-aware module systems and point out further research challenges.Comment: 6 pages, 1 figure, Proceedings of the 3rd International Conference on Model-Driven Engineering and Software Development, pp. 539-545, Angers, France, SciTePress, 201

Computational tasks in robotics and factory automation

The design of Manufacturing Planning and Control Systems (MPCSs) — systems that negotiate with Customers and Suppliers to exchange products in return for money in order to generate profit, is discussed.\ud \ud The computational task of MPCS components are systematically specified as a starting point for the development of computational engines, as computer systems and programs, that execute the specified computation. Key issues are the overwhelming complexity and frequently changing application of MPCSs

Incremental Consistency Checking in Delta-oriented UML-Models for Automation Systems

Automation systems exist in many variants and may evolve over time in order to deal with different environment contexts or to fulfill changing customer requirements. This induces an increased complexity during design-time as well as tedious maintenance efforts. We already proposed a multi-perspective modeling approach to improve the development of such systems. It operates on different levels of abstraction by using well-known UML-models with activity, composite structure and state chart models. Each perspective was enriched with delta modeling to manage variability and evolution. As an extension, we now focus on the development of an efficient consistency checking method at several levels to ensure valid variants of the automation system. Consistency checking must be provided for each perspective in isolation, in-between the perspectives as well as after the application of a delta.Comment: In Proceedings FMSPLE 2016, arXiv:1603.0857

Integrating the common variability language with multilanguage annotations for web engineering

Web applications development involves managing a high diversity of files and resources like code, pages or style sheets, implemented in different languages. To deal with the automatic generation of custom-made configurations of web applications, industry usually adopts annotation-based approaches even though the majority of studies encourage the use of composition-based approaches to implement Software Product Lines. Recent work tries to combine both approaches to get the complementary benefits. However, technological companies are reticent to adopt new development paradigms such as feature-oriented programming or aspect-oriented programming. Moreover, it is extremely difficult, or even impossible, to apply these programming models to web applications, mainly because of their multilingual nature, since their development involves multiple types of source code (Java, Groovy, JavaScript), templates (HTML, Markdown, XML), style sheet files (CSS and its variants, such as SCSS), and other files (JSON, YML, shell scripts). We propose to use the Common Variability Language as a composition-based approach and integrate annotations to manage fine grained variability of a Software Product Line for web applications. In this paper, we (i) show that existing composition and annotation-based approaches, including some well-known combinations, are not appropriate to model and implement the variability of web applications; and (ii) present a combined approach that effectively integrates annotations into a composition-based approach for web applications. We implement our approach and show its applicability with an industrial real-world system.Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech