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.

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.

A Generic Process for the Design and Generation of Software Product Line Skeleton Architectures

2014 ◽  
Vol 24 (09) ◽  
pp. 1301-1335
Author(s):  
Maria Eugenia Cabello ◽  
Isidro Ramos ◽  
Oscar Alberto Santana ◽  
Saúl Iván Beristain
Keyword(s):  
Software Architecture ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Reference Architecture ◽  
Product Lines ◽  
Model Driven ◽  
Software Product ◽  
And Behavior

This paper presents a process, a method and a framework for developing families of software systems in a domain. The process is generic (domain-independent) and produces skeleton software architectures as Software Product Lines. The genericity is supported by the metamodels (abstract languages) that are defined in order to describe the Reference Architecture (structure view, behavior view and variability view) of the system domain. A standardized Production Plan takes the Reference Architecture as input and produces the equivalent Skeleton Software Architecture (component-connector view) using a Feature Model configuration (describing the system to be) as output. This Skeleton Software Architecture includes the structure and behavior of the target software product. A framework has been implemented to support the approach. The process is applied, as an example, to the Diagnostic Expert Systems domain. Our approach is based on Model-Driven Engineering techniques and the Software Product Line paradigm. A domain analysis must be done in order to build the Reference Architecture.

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.

A Method for Prioritizing Integration Testing in Software Product Lines Based on Feature Model

2017 ◽  
Vol 27 (04) ◽  
pp. 575-600
Author(s):  
Zahra Akbari ◽  
Sedigheh Khoshnevis ◽  
Mehran Mohsenzadeh
Keyword(s):  
Software Product Lines ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Test Cases ◽  
Integration Testing ◽  
Product Lines ◽  
Integration Test ◽  
Software Product

Testing activities for software product lines should be different from that of single software systems, due to significant differences between software product line engineering and single software system development. The cost of testing in software product line is generally higher compared with single software systems; therefore, there should exist a certain balance between cost, quality of final products, and the time of performing testing activities. As decreasing testing cost is an important challenge in software product line integration testing, the contribution of this paper is in introducing a method for early integration testing in software product lines based on feature model (FM) by prioritizing test cases in order to decrease integration testing costs in SPLs. In this method, we focus on reusing domain engineering artifacts and prioritized selection and execution of integration test cases. It also uses separation of concerns and pruning techniques on FMs to help prioritize the test cases. The method shows to be promising when applied to some case studies in the sense that it decreases the costs of performing integration test by about 82% and also detects about 44% of integration faults in domain engineering.

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 Generating Software Product Line Model by Resolving Code Smells in the Products’ Source Code

2021 ◽  
Vol 12 (1) ◽  
pp. 1-10
Author(s):  
Sami Ouali
Keyword(s):  
Source Code ◽  
Software Product Line ◽  
Product Line ◽  
Production Costs ◽  
Feature Model ◽  
Software Systems ◽  
Code Smells ◽  
Product Lines ◽  
Bottom Up ◽  
Software Product

Software Product Lines (SPLs) refer to some software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. This concept is recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs by reusing existing features and managing the variability between the different products with respect of particular constraints. Software Product Line engineering is the production process in product lines and the development of a family of systems by reusing core assets. It exploits the commonalities between software products and preserves the ability to vary the functionalities and features between these products. The adopted strategy for building SPL can be a top-down or bottom-up. Depending from the selected strategy, it is possible to face an inappropriate implementation in the SPL Model or the derived products during this process. The code can contain 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 or in the obtained product line when the bottom-up strategy is selected. 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 using the bottom-up strategy. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. This approach proposes a possible solution using reverse engineering to obtain the feature model of the SPL.

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.

Hybrid Model using Firefly and BBO for Feature Selection in Software Product Line

2020 ◽  
Vol 13 ◽  
Author(s):  
Hitesh Yadav ◽  
Rita Chhikara ◽  
Charan Kumari
Keyword(s):  
Hybrid Model ◽  
High Performance ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Feature Sets ◽  
Research Article ◽  
Software Product ◽  
Multiple Variants

Background: Software Product Line is the group of multiple software systems which share the similar set of features with multiple variants. Feature model is used to capture and organize features used in different multiple organization. Objective: The objective of this research article is to obtain an optimized subset of features which are capable of providing high performance. Methods: In order to achieve the desired objective, two methods have been proposed. a) An improved objective function which is used to compute the contribution of each feature with weight based methodology. b) A hybrid model is employed to optimize the Software Product Line problem. Results: Feature sets varying in size from 100 to 1000 have been used to compute the performance of the Software Product Line. Conclusion: The results shows that proposed hybrid model outperforms the state of art metaheuristic algorithms.

Sign in / Sign up

Export Citation Format

Share Document