filter by: Publication Year
(Descending) Articles
IEEE Transactions on Games (24751510) 17(1)pp. 1-12
Model-driven game development (MDGD) leverages the concept of model-driven engineering and game development. The focus of MDGD is to automate the game development process by emphasizing a higher level of abstraction, which will make game development faster and easier. In recent years, researchers in the MDGD community have developed several approaches in this domain. The goal of this article is to survey and classify existing works in MDGD, identify the challenges in this domain, and provide promising future research directions. To achieve this, we conducted a systematic review by selecting 43 articles from a set of 849. The results show that MDE techniques are used to develop games in various genres. 42% of the investigated studies proposed a graphical concrete syntax for game specification and 56% of them used different target environment tools, such as Unity Engine. Moreover, our suggestions include taking advantage of tooling environments and focusing on game components rather than a complete game. © 2024 IEEE.
Journal of Systems and Software (01641212) 219
Context: Modeling is an activity in the software development life cycle where experts and stakeholders collaborate as a team. In collaborative modeling, adhering to the optimistic versioning paradigm allows users to make concurrent changes to the same model, but conflicts may arise. To achieve an integrated and consistent merged model, conflicts must be resolved. Objective: The primary objective of this study was to provide a customizable and extensible framework for conflict management in personalized change propagation during collaborative modeling. Methods: We propose CoMPers, a customizable and extensible conflict management framework designed to address various conflicts encountered in collaborative modeling. We present the duel algorithm for automatically detecting and resolving conflicts according to user preferences. The framework utilizes personalized change propagation to customize collaboration and supports the conflict management process by executing the duel algorithm based on user preferences. As a proof-of-concept, we have implemented the CoMPers framework and extended the EMF.cloud modeling framework to demonstrate its applicability. Results: We have constructed a proof-of-concept implementation and conducted a real-world case study, a benchmark experiment, and a user experience evaluation. Our findings demonstrate that: (1) CoMPers enables collaborators to configure propagation strategies according to their habits; (2) CoMPers successfully identifies all anticipated conflicts and achieves a 100% accuracy in conflict handling; (3) The majority of participants agreed that CoMPers is user-friendly for collaborative modeling. Conclusion: This paper presents the CoMPers framework, which is based on personalized change propagation, and helps collaborators customize conflict management activities. The results confirm the feasibility and advantages of consistent and concurrent modeling within the collaborative CoMPers platform, with an acceptable functionality for approximately ten collaborators. © 2024 Elsevier Inc.
The advancements in technology and widespread internet access have revolutionized the way data collection and polling are conducted. Traditional polling methods are often hampered by significant challenges, including high operational costs, limited ability to reach a broad audience, reliance on a large workforce, and the extensive time required for data analysis. These limitations have led to inefficiencies and reduced the effectiveness of traditional approaches. In this paper, we introduce a platform designed to automate the creation of online polls, utilizing a model-driven approach and no-code development platform. This system streamlines the polling process by allowing users to easily design and deploy polls without extensive programming knowledge. The platform also includes built-in functionalities to automatically generate charts and visualizations for data analysis, reducing the need for manual data processing. By simplifying these processes, the platform makes advanced polling tools accessible to non-experts, enabling quicker, more efficient data collection and analysis in a variety of contexts. © 2025 IEEE.
Frontiers in Computer Science (26249898) 7
Introduction: Natural Language Processing (NLP) and Large Language Models (LLMs) are transforming the landscape of software engineering, especially in the domain of requirement engineering. Despite significant advancements, there is a notable lack of comprehensive survey papers that provide a holistic view of the impact of these technologies on requirement engineering. This paper addresses this gap by reviewing the current state of NLP and LLMs in requirement engineering. Methods: We analyze trends in software requirement engineering papers, focusing on the application of NLP and LLMs. The review highlights their effects on improving requirement extraction, analysis, and specification, and identifies key patterns in the adoption of these technologies. Results: The findings reveal an upward trajectory in the use of LLMs for software engineering tasks, particularly in requirement engineering. The review underscores the critical role of requirement engineering in the software development lifecycle and emphasizes the transformative potential of LLMs in enhancing precision and reducing ambiguities in requirement specifications. Discussion: This paper identifies a growing interest and significant progress in leveraging LLMs for various software engineering tasks, particularly in requirement engineering. It provides a foundation for future research and highlights key challenges and opportunities in this evolving field. Copyright © 2025 Hemmat, Sharbaf, Kolahdouz-Rahimi, Lano and Tehrani.
With the rapid growth of e-commerce and the increasing importance of recommender systems in enhancing customer experience, there is a pressing need for customized systems that can be quickly developed in collaboration with domain experts. In the restaurant industry, this need is particularly acute, as consumers seek personalized dining experiences that cater to their unique tastes and preferences. Effective recommender systems can assist restaurants not only in suggesting menu items based on individual customer profiles but also in adapting to local trends, dietary restrictions, and seasonal ingredients. In this paper, we introduce CURSOR, a novel no-code platform designed to automatically develop customizable recommender systems for restaurants. CURSOR enables businesses to design and deploy tailored systems without the need to hire specialized development teams. Our evaluation results demonstrate that CURSOR reduces development time, lowers costs, and enhances system performance for restaurants. The output from CURSOR enhances customer experience by providing personalized suggestions, which in turn increases satisfaction and encourages purchases. © 2024 IEEE.
Domain model stands as a crucial part of software engineering, emerging from collaborative team efforts. Domain modeling involves creating a conceptual representation of a specific problem domain to determine the concepts and relationships. A pivotal step in domain modeling is reviewing the domain model to identify errors and abnormalities. Typically, software engineers engage in a manual review of the domain model diagrams for refinement purposes. However, the process of detecting errors and abnormalities can be time-consuming and error prone. Furthermore, it relies heavily on the expertise of software engineers. A primary concern in domain modeling is the repetition of concepts, which often occurs due to the involvement of multiple engineers. Recently, AI techniques have exhibited remarkable ability in modeling domain. This paper proposes an approach, called ARDEMIS, for equivalence checking that aims to detect semantically similar concepts within domain models. ARDEMIS utilizes the combination of pre-trained model and dictionary to identify equivalent elements. We assess our approach using a real-world case study in the transportation domain. Our findings reveal the ability of ARDEMIS to identify potential equivalent elements. © 2024 IEEE.
Information (Switzerland) (20782489) 15(10)
The Industrial Internet of Things (IIoT) is pivotal in advancing industrial automation, offering significant improvements in connectivity and efficiency. However, the integration of heterogeneous devices within IIoT systems presents substantial challenges, primarily due to the diversity in device hardware, protocols, and functionalities. In this paper, we propose a new pattern language specifically designed to enhance interoperability and operational efficiency across industrial settings. Drawing from a case study of the State Company for Automotive Industry (S.C.A.I.) in Iraq, this study details the development and integration of eleven interrelated patterns. These patterns were carefully combined based on identified relationships, forming a comprehensive pattern language that addresses key aspects of system heterogeneity, including device communication, data security, and system scalability. The pattern language was validated using the Delphi process theory, engaging industry experts to refine and optimize the framework for practical application. The implementation of this pattern language led to significant improvements in system integration, enabling seamless communication between diverse devices and enhancing operational workflows. The case study demonstrates the practical viability of the proposed pattern language in enhancing interoperability within real-world Industrial Internet of Things (IIoT) applications. Furthermore, the replicable nature of this framework makes it a valuable resource for other industrial environments seeking to harness the power of IIoT technologies. © 2024 by the authors.
Mutation testing is a technique used to assess the effectiveness of software test suites. It works by deliberately introducing small, controlled changes, called mutations, into the code of the software under test (SUT). A robust and thorough test suite should be able to identify and detect these intentionally seeded errors. The key point is to ensure that the resulting mutant program can still be successfully loaded and executed, without causing compilation or runtime errors. The effectiveness of mutation testing directly depends on the nature and scope of the introduced mutations, as more advanced mutations and even targeted mutations can pose additional challenges to the test suite. This paper presents a novel approach leveraging parse trees and grammar fuzzing to create syntactically valid mutations. By generating a parse tree from the SUT’s source code, our method allows precise selection of target nodes and controls mutation granularity through Lexar and parser rules. A custom grammar fuzzer generates new code fragments, which are then semantically validated by a language-specific analyzer to ensure correctness. To address potential compilation issues, we propose selecting deeper parse tree nodes for mutations. Our approach enhances mutation testing precision, flexibility, and automation, ensuring valid and contextually appropriate code mutations. © 2024 IEEE.
CEUR Workshop Proceedings (16130073) 3727pp. 45-49
Model-driven engineering (MDE) copes with the complexity of software development by using the principles of separation of concerns and automatic transformation. In MDE, stakeholders from diverse domains collaborate concurrently on different models to quickly analyze, design, and generate complex software-intensive systems. To adopt an agile development approach in MDE, an inconsistency tolerance framework is needed. This framework postpones the resolution phase for incompatibilities caused by online cooperation, allowing temporary incompatibilities to be automatically fixed while requiring resolution only for the remaining conflicts at the appropriate time. In this paper, we propose a general framework for identifying and diagnosing inconsistencies, making decisions regarding inconsistency tolerance or intervention for resolution, and outlining tolerance strategies in agile systems modeled as multi-views. Our framework comprises three primary phases: detection, analysis, and tolerance. It is designed to identify inconsistencies in multi-view models, which are inherently more complex than single-view models. The tolerance phase employs strategies to tolerate inconsistencies, enhancing the flexibility of the agile development approach for collaborative multi-view modeling. © 2024 Copyright for this paper by its authors.
Software and Systems Modeling (16191374) 22(3)pp. 1031-1079
Model merging conflicts occur when different stakeholders aim to integrate their contradicting changes that are applied concurrently to update software models. We conduct an extensive systematic mapping study on conflict management techniques and relevant collaboration attributes to the versioning and merging models from 2001 to the middle of 2021. This study follows the standard guidelines within the software engineering domain. We analyzed a total of 105 articles extracted from an initial pool of more than 1800 articles to infer a taxonomy for conflict management techniques. We use this taxonomy to classify existing approaches to understand characteristics, shortcomings, and challenges on conflict management techniques in merging models. It also provides a solid foundation for future work in this area. We show that syntactic conflicts are the most studied type and that the top three popular conflict detection techniques are constraint violation, change overlapping, and pattern matching. We observe the lack of a comprehensive state-of-the-art comparison between academic or industrial tools, as well as the need for real-world case studies. Finally, we show that recent trends have focused on online collaboration, where teams of stakeholders work on large-scale models. © 2022, The Author(s), under exclusive licence to Springer-Verlag GmbH Germany, part of Springer Nature.
With the advance of Model-Driven Engineering (MDE), number of generated models has grown exponentially. From the one hand, to provide support for software development using MDE, we need to store various models in the model repositories. From the other hand, extracting a particular model of interest from model repositories is a major challenge. One of the solutions is to use topic tracking in model mining. This provides a rapid and robust exploration that aligns well with the process of finding desired models in complex and large model repositories. In this paper, we propose TrackMine, a genetic algorithm based on topic tracking, to effectively sort the arrangement of models in a repository. This can help modelers realize the tracking, usage, and evolution of the models. TrackMine creates an optimized list of models by rearranging the order of models using user-defined similarity metrics. We demonstrate the applicability of our approach through a proof of concept implementation and evaluate the benefits of the presented algorithm using three different datasets. The experimental results demonstrate the practicality and suitability of our approach for model mining. © 2023 IEEE.
To build complex software-intensive systems, different stakeholders from diverse domains must collaborate to create and modify models. Model matching is a fundamental precondition of collaborative development, which is concerned with identifying common elements in input models. When stakeholders work on multiple models, they need to simultaneously compare all models to better understand differences and similarities. However, the literature shows no consensus on how to specify comparison criteria for matching multiple models, especially in a form that is independent of modeling language, which hampers their reuse and adoption. In this paper, we present a rule-based formalism that enables the user to specify their comparison criteria for multiple models at a high level of abstraction. We also introduce an N-way matching algorithm for comparing both homogeneous and heterogeneous models. As the tool support, we implemented a syntax-Aware editor and a parser for specifying comparison rules for EMF-based models. The evaluation of our formalism shows that it is applicable in real modeling scenarios. © 2022 IEEE.
Business Intelligence (BI) helps organizations in making data-driven decisions by visualizing the current and historical data. Despite the plethora of BI tools, their accessibility and usability are still issues. To alleviate these issues, organizations use Chatbots. However, due to the variety of requirements and different organizational structures, developing a BI chatbot is a complex task that requires the collaboration of technical and BI experts. To address this problem, in this paper, we propose a model-driven approach for the automatic generation of personalized BI chatbots for organizations. The approach is implemented as a framework, which includes two components. First is a modeling component that allows the user to model the business-specific chatbot. Second is an automation component that automatically generates the chatbot code. We conducted a case study to evaluate the applicability of our approach. The results are promising for developing interactive BI chatbots according to various organizational needs. © 2022 IEEE.
Journal of Computer Languages (25901184) 71
Modeling is an activity in the software development life cycle in which different experts and stakeholders collaborate as a team. In collaborative modeling, adhering to the optimistic versioning paradigm allows users to apply concurrent changes to the same model. In such a situation, conflicts may arise. To have an integrated yet consistent merged model, conflicts have to be resolved. To this end, automation is currently at its limit or is not supported at all, and user interaction is often required. To alleviate this flaw, there is an opportunity to apply Artificial Intelligence techniques in a collaborative modeling environment to empower the provisioning of automated and intelligent decision-making. In this paper, we propose the use of reinforcement learning algorithms to achieve merging conflict resolution with a high degree of automation. This enables the personalized and quality-based integration of model versions. To evaluate our idea, we demonstrate the resolution of UML class diagram conflicts using a learning process in an illustrative modeling scenario. We also show the applicability of our approach through a proof of concept implementation and assess its accuracy compared to the greedy and search-based algorithms. Moreover, we conducted an experience with five experts to evaluate the satisfaction of actual users with the selection of resolution actions for different conflicts. The result of the assessment validates our proposal with various syntactic and semantic conflicts. © 2022 Elsevier Ltd
Acta Informatica Pragensia (18054951) 11(2)pp. 179-204
Model-Driven Engineering (MDE) is a software development paradigm that uses models as the main artifacts in the development process. MDE uses model transformations to propagate changes between source and target models. In some development scenarios, target models should be updated based on the evolution of source models. In such cases, it is required to re-execute all transformation rules to update the target model. Incremental execution of transformations, which partially executes the transformation rules, is a solution to this problem. The Epsilon Transformation Language (ETL) is a well-known model transformation language that does not support incremental executions. In this paper, we propose an approach to support the incremental execution of ETL transformations. Our proposal includes a process, as well as a prototype, to propagate changes to the target model. In the proposed approach, all the changes in the source model are detected to identify and re-execute the rules which deal with computing the required elements for updating the target model. We evaluated the correctness and performance of our approach by means of a case study. Compared to the standard ETL, the results are promising regarding the correctness of target models as well as faster execution of the transformation. Copyright: © 2022 by the author(s).
Integrating multiple versions of a model into a unified yet consistent model, which is called N-way merging, is a key challenge in collaborative modeling. Recently, several approaches have been proposed that construct a merged model by incorporating all elements of parallel versions. Despite these efforts, techniques for the high-level specification of N-way merging have hardly been addressed, and research on proposing a formalism for this problem is scarce. Such a formalism can be used to better understand and analyze the behavior of merging real-world systems. This paper presents a formalism to facilitate the specification of the logic behind merging N concurrent versions. The proposed formalism can be used in different merging scenarios to help domain experts analyze their integration requirements more precisely. We introduced three types of merging rules to empower our formalism for specifying all possible scenarios in merging N model versions. We also provide a proof-of-concept implementation in which the N-way merging formalism is equipped with a syntax-aware editor and a parser to promote N-way merging rules for EMF-based models. We conducted a case study to evaluate the applicability of our formalism via a real-world versioning scenario. The results are promising for specifying merging rules in various situations. © 2022 IEEE.
Automated Software Engineering (09288910) 28(1)
In recent years, the number of smartphone users has increased dramatically. These users download millions of apps and use them for various services. Due to the significant demand for mobile apps, developers often seek faster development methods and more effective tools and techniques to generate these apps. Many of these apps are location-based apps in which users receive services based on their geographical location. In this paper, we propose a model-driven approach for the automatic generation of Android location-based mobile apps. Our framework, called ALBA, consists of a domain-specific modeling language, a modeling tool, and a plugin which includes model to code transformations. The modeling tool enables a novice designer to model a location-based app. The model is validated against the predefined constraints and the editor prevents creating invalid models. The designer uses the plugin to generate the Android code of the app. The evaluation of our work is two fold. First, to evaluate the generalizability of the ALBA framework, we conducted an experiment which includes the generation of four industrial location-based apps. Second, to evaluate the usability and quality of both the framework and the generated apps, we conducted a case study consists of three experiments. The results of the evaluation are promising both in terms of the applicability of the framework and the quality of the generated apps. © 2021, The Author(s), under exclusive licence to Springer Science+Business Media, LLC part of Springer Nature.
Building complex software-intensive systems requires effective collaboration between stakeholders from diverse domains. Model-driven engineering (MDE) aims to reduce the complexity of software systems using separation of concerns and continuous evolution of systems at high-level abstraction. When dealing with complex systems, teams of stakeholders with complementary expertise work concurrently on models to produce a coherent and complete system. In such cases, multi-user modeling environments would help designers create and refine models from multiple points of view. Such environments must be adaptable to the needs and interests of stakeholders. To address this requirement, we propose an approach for personalized change propagation in collaborative multi-view modeling. We capture our ideas in the EMF.cloud environment and demonstrate our approach by introducing a multi-user architecture for multi-view collaborative modeling. We express personalized change propagation as a high-level requirement for a collaborative modeling environment and argue that no existing tool satisfies such requirement. Finally, we discuss research challenges for the proposed approach and outline directions for future research. © 2021 IEEE.
Journal of Systems and Software (01641212) 169
The quality of model transformations (MT) has high impact on model-driven engineering (MDE) software development approaches, because of the central role played by transformations in MDE for refining, migrating, refactoring and other operations on models. For programming languages, a popular paradigm for code quality is the concept of technical debt (TD), which uses the analogy that quality flaws in code are a debt burden carried by the software, which must either be ‘redeemed’ by expending specific effort to remove its flaws, or be tolerated, with ongoing additional costs to maintenance due to the flaws. Whilst the analysis and management of quality flaws and TD in programming languages has been investigated in depth over several years, less research on the topic has been carried out for model transformations. In this paper we investigate the characteristics of quality flaws and technical debt in model transformation languages, based upon systematic analysis of over 100 transformation cases in four leading MT languages. Based on quality flaw indicators for TD, we identify significant differences in the level and kinds of technical debt in different MT languages, and we propose ways in which TD in MT can be reduced and managed. © 2020 Elsevier Inc.
Verifying the consistency of model merging is an important step towards the support for team collaboration in software modeling and evolution. Since merging conflicts are inevitable, this has triggered intensive research on conflict management in different domains. Despite these efforts, techniques for high-level conflict representation have hardly been investigated yet. In this paper, we propose an approach to specify model merging conflicts. This approach includes the Conflict Pattern Language (CPL), a formalism for specifying conflicts in different modeling languages. CPL is based on the OCL grammar and is tooled by an editor and a parser. CPL facilitates the slow and error-prone task of specifying model merging conflicts and can be used to specify conflicts in any EMF-based model. We evaluated our approach with a case study, including five different conflict cases. The results are promising about how CPL can be used for specifying syntactic and semantic conflicts. © 2020 Association for Computing Machinery.
Software - Practice and Experience (1097024X) 50(8)pp. 1565-1599
Software development is a collaborative activity that requires teams of software engineers to cooperate and work in parallel on versions of models. However, model management techniques such as model differencing, merging, and versioning have turned out to be difficult challenges, due to the complexity of operations and graph-like nature of models. Therefore, a well-developed support for model merging process, as well as conflict management, is highly desired. This paper presents a novel process for model merging, called the Epsilon-based Three-way Merging Process (E3MP) process. Model merging is a significant problem where there are different versions of a system model amongst modeler teams. E3MP includes three components implemented into the Epsilon framework. First, modelers can define domain-specific rules that customize the merging process. Second, E3MP enables an automated method for syntactic and semantic conflict detection amongst different versions of the system model. Third, E3MP puts forward a pattern-based approach for conflict resolution. We applied two generic benchmarks to assess conflict detection and resolution capabilities of our approach and carried out an initial scalability evaluation for the model merge with large models and large change sets. The results of our experiments revealed that the proposed process allows generating consistent and semantically correct merged models. © 2020 John Wiley & Sons, Ltd.
Journal of Systems and Software (01641212) 140pp. 48-73
Model transformation design patterns have been proposed by a number of researchers, but their usage appears to be sporadic and sometimes patterns are applied without recognition of the pattern. In this paper we provide a systematic literature review of transformation design pattern applications. We evaluate how widely patterns have been used, and how their use differs in different transformation languages and for different categories of transformation. We identify what benefits appear to arise from the use of patterns, and consider how the application of patterns can be improved. The paper also identifies several new patterns which have not previously been catalogued. © 2018 Elsevier Inc.
Lano, K. ,
Alfraihi, H. ,
Rahimi, S.K. ,
Sherbaf, M.R. ,
Haughton h., CEUR Workshop Proceedings (16130073) 2245pp. 203-212
This paper reports on experiences of integrating Agile and Model-Driven Development, for the development of code generators and financial systems. We evaluate the benefits of the Agile MDD approach by comparing Agile non-MDD and Agile MDD developments of code generators, and an agile MDD development of a financial application with three other independent versions of the same application developed using different approaches. We also compare the functionality of the systems and a variety of technical debt metrics measuring the quality of the code and its design. Based on the case study results, we have found evidence that the use of Agile MDD leads to reductions in development effort, and to improvements in software quality and efficiency. © 2018 CEUR-WS. All rights reserved.
Zamani, Bahman ,
Kolahdouz-Rahimi, Shekoufeh ,
Lano, K. ,
Rahimi, S.K. ,
Sherbaf, M.R. ,
Alfraihi, H. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) (03029743) 10888pp. 127-141
Model transformations (MT), as with any other software artifact, may contain quality flaws. Even if a transformation is functionally correct, such flaws will impair maintenance activities such as enhancement and porting. The concept of technical debt (TD) models the impact of such flaws as a burden carried by the software which must either be settled in a 'lump sum' to eradicate the flaw, or paid in the ongoing additional costs of maintaining the software with the flaw. In this paper we investigate the characteristics of technical debt in model transformations, analysing a range of MT cases in different MT languages, and using measures of quality flaws or 'bad smells' for MT, adapted from code measures. Based on these measures we identify significant differences in the level and kinds of technical debt in different MT languages, and we propose ways in which TD can be reduced.
Zamani, Bahman ,
Kolahdouz-Rahimi, Shekoufeh ,
Yassipour-Tehrani, Sobhan ,
Alfraihi, H. ,
Lano, K. ,
Rahimi, S.K. ,
Sherbaf, M.R. ,
Haughton h., Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) (03029743) 11150pp. 229-245
Agile and Model-Driven Development integration (Agile MDD) is of significant interest to researchers who want to leverage the best of both worlds. Currently, there is no clear evidence or proof for the real impact of such integration. As a first step in this direction, this paper reports an empirical investigation on the impact of integrating Agile and Model-Driven Development on the quality of software systems. To this end, we developed a financial application using Agile MDD, which is further contrasted with three other independent versions of the same application developed using different approaches: Agile method, MDD method, and traditional (manually-coded) method, respectively. We also compared the functionality of the systems and a variety of technical debt metrics measuring the quality of the code and its design. Based on the case study results, we have found that the use of Agile MDD shows some improvements in the product quality and efficiency.
Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) (03029743) 10374pp. 108-118
Model transformation design patterns have been proposed by a number of authors, but their usage appears to be sporadic and sometimes patterns are applied without recognition of the pattern. In this paper we provide a literature review of transformation design pattern applications, with regard to their effectiveness and range of use, and consider how pattern usage can be made more effective. © Springer International Publishing AG 2017.
To the challenge entailed by the complexity and size of software systems, developers have to cooperate and work in parallel on software models. Models are changed separately, and they should be merged periodically to obtain an integrated single model. This leads to conflict in merging models. Therefore, several approaches have been proposed to detect such conflicts. For some conflict detection approaches, it is required to describe conflict constraints which are an open issue. In contribution to the solution of this problem, we present a UML profile for modeling conflict conditions which can be used for automatic generation of required constraints. This profile helps to build a conflict model by exploiting example of models which participate in the model merging process. Hence, software engineers are able to define conflicts via a concrete graphical syntax in a familiar UML editor. To evaluate the proposed profile, a case study consisting of two conflicts is performed that shows the usefulness of this profile. © 2017 IEEE.
Model Driven Engineering is a revolutionary paradigm in Software Engineering, which reduces the complexity of development process by increasing the level of abstraction. Model transformation is a soul of MDE, being widely used to map one or more source model(s) into one or more target model(s). Finding an optimal result among a very large search space of possible output transformation models is an important issue in the community. In this paper a unified process for handling the large search space of model transformation results is presented. The process combines model transformation techniques and the genetic algorithm as a search based software engineering (SBSE) technique. The applicability and benefits of the approach is demonstrated using Class Responsibility Assignment (CRA) case study. © 2017 IEEE.
CEUR Workshop Proceedings (16130073) 2026pp. 91-95
The transformation of a finite state automaton into an equivalent regular expression is a challenging topic which is presented in TTC 2017. This paper presents a solution to State Elimination case using the Epsilon framework. Copyright © by the paper's authors. Copying permitted for private and academic purposes.
With the growth of systems complexity the need for verifying the behavior of systems is increasing. UML per se provides no means to check model consistency. However, UML models can be checked if they are converted into their equivalent formal representation. In this paper, we propose an approach based on Model-to-Text transformation to perform a semi-automatic mapping for verification of concurrent UML models using MERL language and MetaEdit+ tool. State machine is transformed into SMV model description and activity diagram is transformed into LTL formulas. Then, we use NuSMV model checker to verify the obtained formal specification. To evaluate the work, a case study of the ordering system is presented to illustrate our approach. A mapping method to check the consistency of state machines with related activity diagrams at early stages of system development is the main result of our work. © 2015 IEEE.
