scholarly journals Taking advantage of the software product line paradigm to generate customized user interfaces for decision-making processes: a case study on university employability

2019 ◽  
Vol 5 ◽  
pp. e203 ◽  
Author(s):  
Andrea Vázquez-Ingelmo ◽  
Francisco J. García-Peñalvo ◽  
Roberto Therón
Keyword(s):  
User Interfaces ◽  
Software Product Line ◽  
Domain Engineering ◽  
Product Line ◽  
Product Lines ◽  
Code Generator ◽  
Software Products ◽  
Software Product ◽  
Spanish Universities

University employment and, specifically, employability has gained relevance since research in these fields can lead to improvement in the quality of life of individual citizens. However, empirical research is still insufficient to make significant decisions, and relying on powerful tools to explore data and reach insights on these fields is paramount. Information dashboards play a key role in analyzing and visually exploring data about a specific topic or domain, but end users can present several necessities that differ from each other, regarding the displayed information itself, design features and even functionalities. By applying a domain engineering approach (within the software product line paradigm), it is possible to produce customized dashboards to fit into particular requirements, by the identification of commonalities and singularities of every product that could be part of the product line. Software product lines increase productivity, maintainability and traceability regarding the evolution of the requirements, among other benefits. To validate this approach, a case study of its application in the context of the Spanish Observatory for University Employability and Employment system has been developed, where users (Spanish universities and administrators) can control their own dashboards to reach insights about the employability of their graduates. These dashboards have been automatically generated through a domain specific language, which provides the syntax to specify the requirements of each user. The domain language fuels a template-based code generator, allowing the generation of the dashboards’ source code. Applying domain engineering to the dashboards’ domain improves the development and maintainability of these complex software products given the variety of requirements that users might have regarding their graphical interfaces.

VARIABILITY MANAGEMENT FOR SOFTWARE PRODUCT-LINE ARCHITECTURE DEVELOPMENT

2011 ◽  
Vol 21 (07) ◽  
pp. 931-956 ◽  
Author(s):  
YOUNG-GAB KIM ◽  
SEOK KEE LEE ◽  
SUNG-BONG JANG
Keyword(s):  
Software Product Line ◽  
Domain Engineering ◽  
Product Line ◽  
Product Lines ◽  
Product Families ◽  
Product Line Architecture ◽  
Software Product ◽  
Key Issues ◽  
Architecture Development

Software Product-Line Engineering (SPLE) is composed of two areas, namely domain engineering and application engineering. Domain engineering is associated with product-line architecture, which is a core asset of the product-line. One of the key issues of the software product-line, especially in domain engineering, is handling the variability among product families. That is, variation management for the software product-line architecture determines the success of software development. Therefore, this paper proposes processes and artifacts to build the software product-line architecture and to manage uniform variability over the life cycle of software product-lines. Furthermore, a case study, namely, the Electronic Medical Record (EMR) system, is presented.

scholarly journals Fragment-oriented programming: a framework to design and implement software product line domain components

DYNA ◽  
2018 ◽  
Vol 85 (207) ◽  
pp. 74-83 ◽  
Author(s):  
Daniel Correa ◽  
Raúl Mazo ◽  
Gloria Lucia Giraldo Goméz
Keyword(s):  
Software Product Line ◽  
Preliminary Evidence ◽  
Product Line ◽  
Software Systems ◽  
Software Components ◽  
Product Lines ◽  
Reusable Software ◽  
Software Products ◽  
Manual Intervention ◽  
Software Product

Software product lines facilitate the industrialization of software development. The main goal is to create a set of reusable software components for the rapid production of a software systems family. Many authors have proposed different approaches to design and implement the components of a product line. However, the construction and integration of these components continue to be a complex and time-consuming process. This paper introduces Fragment-oriented programming (FragOP), a framework to design and implement software product line domain components, and derive software products. FragOP is based on: (i) domain components, (ii) fragmentations points and (iii)fragments. FragOP was implemented in the VariaMos tool and using it we created a clothing stores software product line. We derivedfive different products, integrating automatically thousands of lines of code. On average, only three lines of code were manually modified;which provided preliminary evidence that using FragOP reduces manual intervention when integrating domain components.

scholarly journals Feature Model Configuration Based on Two-Layer Modelling in Software Product Lines

2019 ◽  
Vol 9 (4) ◽  
pp. 2648
Author(s):  
Elham Darmanaki Farahani ◽  
Jafar Habibi
Keyword(s):  
Product Line ◽  
Feature Model ◽  
Functional Requirements ◽  
Product Lines ◽  
Software Products ◽  
Model Configuration ◽  
Software Product ◽  
Software And Hardware ◽  
Application Requirements

The aim of the Software Product Line (SPL) approach is to improve the software development process by producing software products that match the stakeholders’ requirements. One of the important topics in SPLs is the feature model (FM) configuration process. The purpose of configuration here is to select and remove specific features from the FM in order to produce the required software product. At the same time, detection of differences between application’s requirements and the available capabilities of the implementation platform is a major concern of application requirements engineering. It is possible that the implementation of the selected features of FM needs certain software and hardware infrastructures such as database, operating system and hardware that cannot be made available by stakeholders. We address the FM configuration problem by proposing a method, which employs a two-layer FM comprising the application and infrastructure layers. We also show this method in the context of a case study in the SPL of a sample E-Shop website. The results demonstrate that this method can support both functional and non-functional requirements and can solve the problems arising from lack of attention to implementation requirements in SPL FM selection phase.

scholarly journals Resolving Code Smells in Software Product Line using Refactoring and Reverse Engineering

2020 ◽  
Author(s):  
Sami Ouali
Keyword(s):  
Reverse Engineering ◽  
Source Code ◽  
Software Product Line ◽  
Product Line ◽  
Production Costs ◽  
Code Smells ◽  
Product Lines ◽  
Software Products ◽  
Software Product ◽  
External Behavior

Software Product Lines (SPL) are recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs. This approach allows products to be different with respect of particular characteristics and constraints in order to cover different markets. Software Product Line engineering is the production process in product lines. It exploits the commonalities between software products, but also to preserve the ability to vary the functionality between these products. Sometimes, an inappropriate implementation of SPL during this process can conduct to code smells or code anomalies. Code smells are considered as problems in source code which can have an impact on the quality of the derived products of an SPL. The same problem can be present in many derived products from an SPL due to reuse. A possible solution to this problem can be the refactoring which can improve the internal structure of source code without altering external behavior. This paper proposes an approach for building SPL from source code. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. Another part of the approach consists on obtained SPL’s design based on reverse engineering.

scholarly journals Properties of a Feature in Code-Assets: An Exploratory Study

2021 ◽  
Vol 12 (5) ◽  
pp. 41-53
Author(s):  
Armaya’u Zango Umar ◽  
Jaejoon Lee
Keyword(s):  
Software Product Line ◽  
Domain Engineering ◽  
Product Line ◽  
Product Line Engineering ◽  
Software Products ◽  
Software Product Line Engineering ◽  
Software Product ◽  
Application Engineering ◽  
Usage Context ◽  
Line Engineering

Software product line engineering is a paradigm for developing a family of software products from a repository of reusable assets rather than developing each individual product from scratch. In featureoriented software product line engineering, the common and the variable characteristics of the products are expressed in terms of features. Using software product line engineering approach, software products are produced en masse by means of two engineering phases: (i) Domain Engineering and, (ii) Application Engineering. At the domain engineering phase, reusable assets are developed with variation points where variant features may be bound for each of the diverse products. At the application engineering phase, individual and customized products are developed from the reusable assets. Ideally, the reusable assets should be adaptable with less effort to support additional variations (features) that were not planned beforehand in order to increase the usage context of SPL as a result of expanding markets or when a new usage context of software product line emerges. This paper presents an exploration research to investigate the properties of features, in the code-asset implemented using Object-Oriented Programming Style. In the exploration, we observed that program elements of disparate features formed unions as well as intersections that may affect modifiability of the code-assets. The implication of this research to practice is that an unstable product line and with the tendency of emerging variations should aim for techniques that limit the number of intersections between program elements of different features. Similarly, the implication of the observation to research is that there should be subsequent investigations using multiple case studies in different software domains and programming styles to improve the understanding of the findings.

scholarly journals Taxonomy-Oriented Domain Analysis of GIS: A Case Study for Paleontological Software Systems

2019 ◽  
Vol 8 (6) ◽  
pp. 270
Author(s):  
Agustina Buccella ◽  
Alejandra Cechich ◽  
Juan Porfiri ◽  
Domenica Diniz Dos Santos
Keyword(s):  
Domain Analysis ◽  
Software Product Line ◽  
Product Line ◽  
Software Systems ◽  
Product Lines ◽  
North Patagonia ◽  
Building Systems ◽  
Software Product ◽  
Open Issue

Documenting the paleontological process includes data produced by different techniques and protocols, which are used by paleontologists to prospect and eventually find a new fossil. Nowadays, together with the aforementioned data, a great amount of information is also available in terms of georeferenced systems, including contextual as well as descriptive information. However, the use of this information into a model capable of recognizing similarities and differences is still an open issue within the Natural Heritage community. From the software engineering field, software product lines are models that focus on reusing common assets, in such a way that new software developments are only concern on differentiation relying on already modeled (and implemented) systems. This synergy leads us to apply our taxonomy-oriented domain analysis for Software Product Line (SPL) development, when building systems for documenting the paleontological process. In this paper, we introduce the approach for building such software systems, and illustrate its use through a case study in North Patagonia. Findings show promissory results in terms of reuse.

Configuration Management Model in Evolutionary Software Product Line

2016 ◽  
Vol 26 (03) ◽  
pp. 433-455 ◽  
Author(s):  
Elham Darmanaki Farahani ◽  
Jafar Habibi
Keyword(s):  
System Development ◽  
Configuration Management ◽  
Software Product Line ◽  
Product Line ◽  
Product Lines ◽  
Software Product ◽  
Level Of Aggregation ◽  
Release Management ◽  
The One

In Software Product Line (SPL), Configuration Management (CM) is a multi-dimensional problem. On the one hand, the Core Assets that constitute a configuration need to be managed, and on the other hand, each product in the product line that is built using a configuration must be managed, and furthermore, the management of all these configurations must be coordinated under a single process. Therefore, CM for product lines is more complex than for single systems. The CM of any software system involves four closely related activities: Change Management (ChM), Version Management (VM), System Building (SB) and Release Management (RM) [I. Sommerville, Software Engineering, 9th edn. (Addison-Wesley, 2010)]. The aim of this paper is to provide ChM and VM models for evolutionary-based SPL system development and maintenance. The proposed models support any level of aggregation in SPLs and have been applied to Mobile SPL as a case study.

Sign in / Sign up

Export Citation Format

Share Document