Software with microservice architecture consists of a collection of small and independent services. Those services can be combined and modified to serve various purposes, which leads to an increase in requirement variability. The variability needs to be documented to track any changes and optimize the reusability. The issues are related to variability management, which is one of the main concerns in software product line engineering (SPLE). We propose an approach to re-engineer microservice applications into SPLE. The process comprises variability modeling, architectural design, and product line implementation. To model the variability in microservices, we use a multi-level feature diagram. The feature diagram is combined with the UML class diagram from existing systems to design a product line architecture. We utilize the UML-DOP profile that provides an extension to represent delta-oriented concepts in the UML notation. UML diagrams with UML-DOP profile are used to capture several levels of abstractions in the architectural models. These models enable traceability from requirements to endpoints implementation. The proposed approach is shown by performing a re-engineering for existing microservice-based webshop systems. The result is a microservices-based product line that can be generated into various applications.
In web application development, engineers must implement the User Interface (UI) using diverse implementation artifacts such as HTML, CSS, and JavaScript. Employing a Model-Driven Engineering (MDE) for developing UI may reduce the development effort by automatically generating these artifacts. Additionally, we can combine an MDE approach with Software Product Line (SPL) concepts to model and generate UI variants automatically. However, UI development is a complex and multi-faceted problem. The UI must satisfy the customer preferences for various aspects (e.g., coloring scheme, choice of UI elements, and layouts) while also having a good usability level. Purely generated UI is often unable to comply with these requirements and thus forces the engineers to develop the UI manually instead. In this paper, we proposed an approach for managing customizable UI variants in the context of a web application product line. Our approach uses Interaction Flow Modeling Language (IFML) to model web application UI. Additionally, we define a delta modeling extension for IFML to support modeling UI variants. We implement a tool support that allows engineers to use our approach for modeling and generating UI variants. The tool support also provides a mechanism for UI customization based on developing a set of interchangeable interface styles. We evaluated the feasibility of our approach by applying it to three case studies and conducted a questionnaire survey to assess the usability of the generated UI variants. Our evaluation results show that our approach can be a good starting point to manage UI variants with good usability.
Precise Requirement Changes Integrated System (PRICES) is a framework to develop a web-based product line. PRICES is designed based on model-driven engineering and delta-oriented programming. The goal of this tutorial is to introduce how PRICES can be used to model the problem domain and generate a running web application. The tutorial is planned to be conducted in a half-day. A combination of lecture and hands-on training will be provided. In addition, we will demonstrate a possibility of a semi-automatic approach to generate a web application using SPLE. Participants can try to develop a new variation and generate an application using a running case study.
We present a realization of multi software product lines in the Java programming language that permits full interoperability and hierarchical dependencies among multiple product variants. This concept, called variability modules (VM), is implemented in terms of an architectural pattern in Java and does not require any pre-processing or language extension. It can be used with any Java development environment. The VM architectural pattern comes with a dedicated UML profile, which makes it possible to present variability to non-technical stakeholders. We evaluate our approach with the help of a real-world case study.
Combining microservices and software product line engineering (SPLE) is a challenge in variability management. This paper proposes a solution to that challenge by re-engineering existing webshop systems into a product line application. We first perform feature identification to analyze the features of subject systems. We introduce a mechanism that models the variability and designs a software product line architecture based on existing features. We use a UML diagram with the UML-DOP profile to abstract microservice variability in SPLE. Then, a transformation into a product line application is conducted to generate running applications based on selected features. We utilize a preliminary framework of microservice variability based on delta-oriented programming.
Software product line engineering (SPLE) is an approach in software development that produces various products based on commonality and variability. SPLE maintains the product variations within two main phases: domain engineering and application engineering. Lack of adequate technology and tools support is one of the problems in adopting SPLE. In this research, a model-driven approach based on delta-oriented programming is proposed for SPLE. The process starts with the domain analysis phase by defining a feature diagram and Unified Modeling Language (UML) based on existing systems. While those models represent the problem domain, delta-oriented programming with abstract behavioral specification (ABS) language is used in the solution domain. This approach is supported by automated model transformations, which transform the feature diagram and UML to ABS models. A code generator mechanism is also used to produce a running application based on ABS models. When the user selects features in this application, our tools generate the running application based on those selections. We provide a running example, a charity organization system, as a case study. Therefore, this research proposes an entire SPLE process based on a model-driven approach that covers the problem and solution domains and produces a running application.
We choose Unified Modeling Language (UML) as the foundation to model the proposed solution of the Multi Software Product Lines (MPL) interoperability challenge. The proposed pseudo-code is modeled as an extension of the UML meta-model to support MPL. The model serves to provide a standard representation of MPL and an intuitive transformation to an Object-Oriented Programming (OOP) language. Some extension to the UML that yet to have intuitive translation into common OO language are augmented with a mechanism using a build automation system. This mechanism provides manual transformation that gives us some hints whether the proposed solution fulfilled the evaluation criteria. The given challenge case has been written in our proposed pseudo-code, modeled in our UML extension, and translated into Java source code and Gradle build scripts. By invoking Gradle tasks, we can simulate product generation that creates products as Java objects.
We explore the possibility of including Delta-Oriented Programming (DOP) and Abstract User Interface (AUI) model during product generation in Software Product Line Engineering (SPLE). Previous work showed that DOP is applicable in a SPLE for Web applications albeit User Interface (UI) elements in derived product are still manually created without UI modeling. AUI model is proven to be successful for modeling UI elements for products in SPLE as it can model generic UI elements while still encouraging customization. Therefore, we pick an existing AUI modeling language called Interaction Flow Modeling Language (IFML) to create model of UI elements in a SPLE. We also suggest a new SPLE design that follows DOP and the proposed UI modeling language to generate adaptable UI given product configuration. The process of designing UI for each feature in the product line is based on reference implementation process used in previous work. We hope that the suggested process can solve the current DOP practices limitation in generating UI elements for products in SPLE.
Microservices architecture is a software development style that divides software into several small, independently deployable services. Every service can be invoked by standard protocols such as HTTP, so it can be used on a variety of platforms (e.g. mobile, web, desktop). The diversity of users of microservices-based software causes an increased variation in software requirements. In order to accommodate this ariability, we propose a framework for microservices-based software based on the Software Product Line Engineering (SPLE) approach. We call this framework ABS Microservices Framework, as it relies on the Abstract Behavioral Specification (ABS) language development platfor that readily supports SPLE. The framework created in this research has shown more flexibility to accommodate software variability than other microservices frameworks. Hence, the ABS Microservices Framework can support the software industry to distribute variable software of high quality and reliability
Feature-based approaches to software design, like delta-oriented programming, are well-suited to support multi-product software development paradigms, such as Software Product Lines. Currently, the popular UML notation does not support delta-oriented software design, so that several ad-hoc notations tend to be used. This paper presents a systematic approach to import concepts from delta-oriented programming into the mainstream notation UML. This is done with minimal overhead by specifying a new, slim, delta-oriented UML profile. It is compatible with languages that support delta-oriented programming such as DeltaJ and ABS. The usefulness of the profile is evaluated with a case study.
We investigated how a software product line (SPL) for Web application is realized by following an established Web application development methodology called Architecture-Centric Model-Driven Web Engineering (AC-MDWE). The development process is done by using Abstract Behavioural Specification (ABS), which is an executable modelling language that provides SPL-related features. We created a case study by implementing a product line for E-commerce Web applications. The product line is realisable using ABS with modifications to the original AC-MDWE process. ABS can provide several benefits such as control during product generation, feature traceability, and preserving integrity of core assets. However, it is still not ready for creating production-level Web application and lack of readability in the generated artefacts.