1,589 research outputs found
Automatically Discovering Hidden Transformation Chaining Constraints
Model transformations operate on models conforming to precisely defined
metamodels. Consequently, it often seems relatively easy to chain them: the
output of a transformation may be given as input to a second one if metamodels
match. However, this simple rule has some obvious limitations. For instance, a
transformation may only use a subset of a metamodel. Therefore, chaining
transformations appropriately requires more information. We present here an
approach that automatically discovers more detailed information about actual
chaining constraints by statically analyzing transformations. The objective is
to provide developers who decide to chain transformations with more data on
which to base their choices. This approach has been successfully applied to the
case of a library of endogenous transformations. They all have the same source
and target metamodel but have some hidden chaining constraints. In such a case,
the simple metamodel matching rule given above does not provide any useful
information
A Comparative Study on Model-Driven Requirements Engineering for Software Product Lines
[EN] Model-Driven Engineering (MDE) and Software Product Lines (SPL) are two software development paradigms that emphasize reusing. The former reuse domain knowledge is represented as models and model transformations for product development, and the latter reuse domain knowledge is represented as core assets to produce a family of products in a given domain. The adequate
combination of both paradigms can bring together important advantages to the software development community. However, how to manage requirements during a model-driven product line development remains an open challenge. In particular, the Requirements Engineering (RE) activity must deal with specific
properties such as variability and commonality for a whole family of products. This paper presents a comparative study of eleven approaches that perform a MDE strategy in the RE activity for SPL, with the aim of identify ing current practices and research gaps. In summary, most of the approaches are focused on the Domain Engineering phase of the SPL development, giving less attention to the Application Engineering phase. Moreover there is a lack of
coverage of the Scoping activity, which defines the SPL boundaries. Several approaches apply some model transformations to obtain architectural and application requirements artifacts. Regarding the tool support for requirements specification and management, we found that most of the approaches use only academic prototypes. Regarding the validation of the approaches, the use of Case Studies as a proof of concept was the most commonly used method; however, there is a lack of well-defined case studies and empirical studies to
improve the proposals.This research is part of the MULTIPLE project (with ref. TIN2009-13838).Blanes DomĂnguez, D.; Insfrán Pelozo, CE. (2012). A Comparative Study on Model-Driven Requirements Engineering for Software Product Lines. Revista de Sistemas e Computação. 2(1):3-13. http://hdl.handle.net/10251/43841S3132
Review of Requirement Engineering Approaches for Software Product Lines
The Software Product Lines (SPL) paradigm is one of the most recent topics of interest for the software engineering community. On the one hand, the Software Product Lines is based on a reuse strategy with the aim to reduce the global time-to-market of the software product, to improve the software product quality, and to reduce the cost. On the other hand, traditional Requirement Engineering approaches could not be appropriated to deal with the new challenges that arises the SPL adoption. In the last years, several approaches have been proposed to cover this limitation. This technical report presents an analysis of specific approaches used in the development of SPL to provide solutions to model variability and to deal with the requirements engineering activities. The obtained results show that most of the research in this context is focused on the Domain Engineering, covering mainly the Feature Modeling and the Scenario Modeling. Among the studied approaches, only one of them supported the delta identification; this fact implies that new mechanisms to incorporate new deltas in the Domain specification are needed. Regarding the SPL adoption strategy, most of the approaches support a proactive strategy. However, this strategy is the most expensive and risk-prone. Finally, most of the approaches were based on modeling requirements with feature models giving less support to other important activities in the requirements engineering process such as elicitation, validation, or verification of requirements. The results of this study provide a wide view of the current state of research in requirements engineering for SPL and also highlight possible research gaps that may be of interest for researchers and practitioners.Blanes DomĂnguez, D.; Insfrán Pelozo, CE. (2011). Review of Requirement Engineering Approaches for Software Product Lines. http://hdl.handle.net/10251/1023
Pattern-based refactoring in model-driven engineering
L’ingénierie dirigée par les modèles (IDM) est un paradigme du génie logiciel qui utilise les
modèles comme concepts de premier ordre à partir desquels la validation, le code, les tests
et la documentation sont dérivés. Ce paradigme met en jeu divers artefacts tels que les
modèles, les méta-modèles ou les programmes de transformation des modèles. Dans un
contexte industriel, ces artefacts sont de plus en plus complexes. En particulier, leur
maintenance demande beaucoup de temps et de ressources. Afin de réduire la complexité
des artefacts et le coût de leur maintenance, de nombreux chercheurs se sont intéressés au
refactoring de ces artefacts pour améliorer leur qualité.
Dans cette thèse, nous proposons d’étudier le refactoring dans l’IDM dans sa
globalité, par son application à ces différents artefacts. Dans un premier temps, nous
utilisons des patrons de conception spécifiques, comme une connaissance a priori, appliqués
aux transformations de modèles comme un véhicule pour le refactoring. Nous procédons
d’abord par une phase de détection des patrons de conception avec différentes formes et
différents niveaux de complétude. Les occurrences détectées forment ainsi des opportunités
de refactoring qui seront exploitées pour aboutir à des formes plus souhaitables et/ou plus
complètes de ces patrons de conceptions.
Dans le cas d’absence de connaissance a priori, comme les patrons de conception,
nous proposons une approche basée sur la programmation génétique, pour apprendre des
règles de transformations, capables de détecter des opportunités de refactoring et de les
corriger. Comme alternative à la connaissance disponible a priori, l’approche utilise des
exemples de paires d’artefacts d’avant et d’après le refactoring, pour ainsi apprendre les
règles de refactoring. Nous illustrons cette approche sur le refactoring de modèles.Model-Driven Engineering (MDE) is a software engineering paradigm that uses models as
first-class concepts from which validation, code, testing, and documentation are derived.
This paradigm involves various artifacts such as models, meta-models, or model
transformation programs. In an industrial context, these artifacts are increasingly complex.
In particular, their maintenance is time and resources consuming. In order to reduce the
complexity of artifacts and the cost of their maintenance, many researchers have been
interested in refactoring these artifacts to improve their quality.
In this thesis, we propose to study refactoring in MDE holistically, by its application
to these different artifacts. First, we use specific design patterns, as an example of prior
knowledge, applied to model transformations to enable refactoring. We first proceed with a
detecting phase of design patterns, with different forms and levels of completeness. The
detected occurrences thus form refactoring opportunities that will be exploited to implement
more desirable and/or more complete forms of these design patterns.
In the absence of prior knowledge, such as design patterns, we propose an approach
based on genetic programming, to learn transformation rules, capable of detecting
refactoring opportunities and correcting them. As an alternative to prior knowledge, our
approach uses examples of pairs of artifacts before and after refactoring, in order to learn
refactoring rules. We illustrate this approach on model refactoring
Towards Automatic Support of Software Model Evolution with Large Language~Models
Modeling structure and behavior of software systems plays a crucial role, in
various areas of software engineering. As with other software engineering
artifacts, software models are subject to evolution. Supporting modelers in
evolving models by model completion facilities and providing high-level edit
operations such as frequently occurring editing patterns is still an open
problem. Recently, large language models (i.e., generative neural networks)
have garnered significant attention in various research areas, including
software engineering. In this paper, we explore the potential of large language
models in supporting the evolution of software models in software engineering.
We propose an approach that utilizes large language models for model completion
and discovering editing patterns in model histories of software systems.
Through controlled experiments using simulated model repositories, we conduct
an evaluation of the potential of large language models for these two tasks. We
have found that large language models are indeed a promising technology for
supporting software model evolution, and that it is worth investigating further
in the area of software model evolution
Recommended from our members
A Framework for Automatic Dynamic Constraint Verification in Cyber Physical System Modeling Languages
Design of Cyber-Physical Systems (CPSs) involves overlapping the domains of control theory, network communication, and computational algorithms. Involving multiple domains within the same design greatly increases the system complexity. Furthermore, the physical nature of CPSs generally involves important safety constraints where constraint violations can be catastrophic. The design of CPSs benefits from focusing on the construction of abstracted, high-level models in a DomainSpecific Modeling Language (DSML). A Domain-Specific Modeling Environment (DSME) may aid in the design of such complex systems by enforcing structural design constraints during the construction of models. Models built using a DSME may also use compilers or interpreters to produce real working, low-level artifacts that represent the high-level design. Though each model in a DSME may abide by a formal specification, the behavior of a design may violate dynamic constraints if deployed. Engineers are tasked to ensure that models behave safely by implementing their expert knowledge after using appropriate verification tools. Constraint violations may be eliminated by a modification of the model based on verification feedback, known as Dynamic Constraint Feedback (DCF). Mending such constraint violations is a task generally performed by the model designer. Such a process could potentially be automated through the capture of well-known design practices. The challenging task when automating model correction then becomes in the design of a DSML. A designer of a DSML may have a clear understanding of how to design the syntax and semantics for their domain, but there are no formal methods for implementing verification tools for automatic model correction. Such a framework could greatly aid in the selection of available verification tools, implement well-established design methods, and model dynamic constraints. Presented is the Dynamic Constraint Feedback Metamodeling Language (DCFML), a new metamodel to implement DCF upfront in DSML design. This particular solution provides a concrete solution to the abstraction of the various components of DCF, and then appends them to the DSML design process provided by a DSME
OpenUP/MDRE: A Model-Driven Requirements Engineering Approach for Health-Care Systems
The domains and problems for which it would be desirable to introduce information systems are currently very complex and the software development process is thus of the same complexity. One of these domains is health-care. Model-Driven Development (MDD) and Service-Oriented Architecture (SOA) are software development approaches that raise to deal with complexity, to reduce time and cost of development, augmenting flexibility and interoperability. However, many techniques and approaches that have been introduced are of little use when not provided under a formalized and well-documented methodological umbrella. A methodology gives the process a well-defined structure that helps in fast and efficient analysis and design, trouble-free implementation, and finally results in the software product improved quality.
While MDD and SOA are gaining their momentum toward the adoption in the software industry, there is one critical issue yet to be addressed before its power is fully realized. It is beyond dispute that requirements engineering (RE) has become a critical task within the software development process. Errors made during this process may have negative effects on subsequent development steps, and on the quality of the resulting software. For this reason, the MDD and SOA development approaches should not only be taken into consideration during design and implementation as usually occurs, but also during the RE process.
The contribution of this dissertation aims at improving the development process of health-care applications by proposing OpenUP/MDRE methodology. The main goal of this methodology is to enrich the development process of SOA-based health-care systems by focusing on the requirements engineering processes in the model-driven context. I believe that the integration of those two highly important areas of software engineering, gathered in one consistent process, will provide practitioners with many benets. It is noteworthy that the approach presented here was designed for SOA-based health-care applications, however, it also provides means to adapt it to other architectural paradigms or domains. The OpenUP/MDRE approach is an extension of the lightweight OpenUP methodology for iterative, architecture-oriented and model-driven software development. The motivation for this research comes from the experience I gained as a computer science professional working on the health-care systems. This thesis also presents a comprehensive study about: i) the requirements engineering methods and techniques that are being used in the context of the model-driven development, ii) known generic but flexible and extensible methodologies, as well as approaches for service-oriented systems development, iii) requirements engineering techniques used in the health-care industry. Finally, OpenUP/MDRE was applied to a concrete industrial health-care project in order to show the feasibility and accuracy of this methodological approach.Loniewski, G. (2010). OpenUP/MDRE: A Model-Driven Requirements Engineering Approach for Health-Care Systems. http://hdl.handle.net/10251/11652Archivo delegad
- …