Transformação de modelos SysML para UML usando a linguagem ATL

The virtue of quality is not itself a subject; it depends on a subject. In the software engineering field, quality means good software products that meet customer expectations, constraints, and requirements. Despite the numerous approaches, methods, descriptive models, and tools, that have been developed, a level of consensus has been reached by software practitioners. However, in the model-driven engineering (MDE) field, which has emerged from software engineering paradigms, quality continues to be a great challenge since the subject is not fully defined. The use of models alone is not enough to manage all of the quality issues at the modeling language level. In this work, we present the current state and some relevant considerations regarding quality in MDE, by identifying current categories in quality conception and by highlighting quality issues in real applications of the model-driven initiatives. We identified 16 categories in the definition of quality in MDE. From this identification, by applying an adaptive sampling approach, we discovered the five most influential authors for the works that propose definitions of quality. These include (in order): the OMG standards (e.g., MDA, UML, MOF, OCL, SysML), the ISO standards for software quality models (e.g., 9126 and 25,000), Krogstie, Lindland, and Moody. We also discovered families of works about quality, i.e., works that belong to the same author or topic. Seventy-three works were found with evidence of the mismatch between the academic/research field of quality evaluation of modeling languages and actual MDE practice in industry. We demonstrate that this field does not currently solve quality issues reported in industrial scenarios. The evidence of the mismatch was grouped in eight categories, four for academic/research evidence and four for industrial reports. These categories were detected based on the scope proposed in each one of the academic/research works and from the questions and issues raised by real practitioners. We then proposed a scenario to illustrate quality issues in a real information system project in which multiple modeling languages were used. For the evaluation of the quality of this MDE scenario, we chose one of the most cited and influential quality frameworks; it was detected from the information obtained in the identification of the categories about quality definition for MDE. We demonstrated that the selected framework falls short in addressing the quality issues. Finally, based on the findings, we derive eight challenges for quality evaluation in MDE projects that current quality initiatives do not address sufficiently.

Model-Driven Engineering (MDE) is changing the way we build, operate, and maintain our software-intensive systems. Several projects using MDE practices are reporting significant improvements in quality and performance but, to be able to handle these projects, software engineers need a set of technical and interpersonal skills that are currently not widely available. The MDE postgraduate diploma intends to fill this gap by offering a full-time one year formation onMDE. The course syllabus is designed to teach students how to work at a higher abstraction level by the rigorous use of (software) models as the main artifacts in all software engineering activities. Contents include the conceptual framework of MDE plus all techniques and tools (e.g. for defining modeling languages, models, and model transformations) required to successfully complete software engineering projects following a MDE approach. The organizational impact (and challenges) of adopting MDE are exemplified using real industrial experiences. This article describes the MDE Diploma and the lessons that we learned after completing its first edition.

This proposal is about a study we recently published in the IEEE Transaction of Software Engineering journal [4]. Context: Collaborative software engineering (CoSE) deals with methods, processes and tools for enhancing collaboration, communication, and co-ordination (3C) among team members [5]. CoSE can be employed to conceive different kinds of artifacts during the development and evolution of software systems. For instance, when focusing on software design, multiple stakeholders with different expertise and responsibility collaborate on the system design. Model-Driven Software Engineering (MDSE) provides suitable techniques and tools for specifying, manipulating, and analyzing modeling artifacts including metamodels, models, and transformations [1]. Collaborative MDSE consists of methods or techniques in which multiple stakeholders manage, collaborate, and are aware of each others' work on a set of shared models. A collaborative MDSE approach is composed of three main complementary dimensions: (i) a model management infrastructure for managing the life cycle of the models, (ii) a set of collaboration means for allowing involved stakeholders to work on the modelling artifacts collaboratively, and (iii) a set of communication means for allowing involved stakeholders to exchange, share, and communicate information within the team. Collaborative MDSE is attracting several research efforts from different research areas (e.g., model-driven engineering, global software engineering, etc.), resulting in a variegated scientific body of knowledge on the topic. Objective: In this study we aim at identifying, classifying, and understanding existing collaborative MDSE approaches. More specifically, our goal is to assess (i) the key characteristics of collaborative MDSE approaches (e.g., model editing environments, model versioning mechanisms, model repositories, support for communication and decision making), (ii) their faced challenges and limitations, and (iii) the interest of researchers in collaborative MDSE approaches over time and their focus on the three dimensions of collaborative MDSE. Method: In order to achieve this, we designed and conducted a systematic mapping study [6] on collaborative MDSE. Starting from over 3,000 potentially relevant studies, we applied a rigorous selection procedure [3] resulting in 106 selected papers, further clustered into 48 primary studies, along a time span of nineteen years. A suitable classification framework has been empirically defined and rigorously applied for extracting key information from each selected study. We collated, summarized, and analyzed extracted data by applying scientifically sound data synthesis techniques. Results: In addition to a number of specific insights, our analysis revealed the following key findings: (i) there is a growing scientific interest on collaborative MDSE in the last years; (ii) multi-view modeling, validation support, reuse, and branching are more rarely covered with respect to other aspects about collaborative MDSE; (iii) different primary studies focus differently on individual dimensions of collaborative MDSE (i.e., model management, collaboration, and communication); (iv) most approaches are language-specific, with a prominence of UML-based approaches; (v) few approaches support the interplay between synchronous and asynchronous collaboration. Conclusion: This study gives a solid foundation for a thorough identification and comparison of existing and future approaches for collaborative MDSE [2]. Those results can be used by both researchers and practitioners for identifying existing research/technical gaps to attack, better scoping their own contributions to the field, or better understanding or refining existing ones.

The development of self-adaptive software requires the engineering of an adaptation engine that controls the underlying adaptable software by feedback loops. The engine often describes the adaptation by runtime models representing the adaptable software and by activities such as analysis and planning that use these models. To systematically address the interplay between runtime models and adaptation activities, runtime megamodels have been proposed. A runtime megamodel is a specific model capturing runtime models and adaptation activities. In this article, we go one step further and present an executable modeling language for ExecUtable RuntimE MegAmodels (EUREMA) that eases the development of adaptation engines by following a model-driven engineering approach. We provide a domain-specific modeling language and a runtime interpreter for adaptation engines, in particular feedback loops. Megamodels are kept alive at runtime and by interpreting them, they are directly executed to run feedback loops. Additionally, they can be dynamically adjusted to adapt feedback loops. Thus, EUREMA supports development by making feedback loops explicit at a higher level of abstraction and it enables solutions where multiple feedback loops interact or operate on top of each other and self-adaptation co-exists with offline adaptation for evolution.

In Software Engineering as in all other engineering fields, the product to be build is divided into sub-parts that are independently constructed and subsequently assembled. This procedure reduces the complexity and improves the reuse of the developed products. MDE (Model Driven Engineering) is a recent software engineering discipline that focuses this approach. It has allowed several significant improvements in the development of complex software systems by providing the means that enable to switch from one abstraction level into another or from one modeling space into another. However, models management may be tedious and costly. Thus, it is necessary to provide some flexible and reliable tools for automatic management of models and some techniques for their transformations in order to live up to user expectations. In this context, model composition has become an important artifact in the MDE domain that allows constructing and composing an efficient assembly process. In this paper, we present the state of the art of recent works in the model composition methods and techniques by focusing on the various parameters that govern and characterize their behavior.

THALES is a supplier of complex systems in the Defence and Aerospace domains. A number of THALES Units are currently involved in transitioning parts of their systems and software engineering processes from document-driven to model-driven engineering (MDE). MDE puts models on the critical path of system and software development, turning the role of model from contemplative to productive. Putting MDE into practice in operational contexts intrinsically puts heavy demands on the tooled-up process.A first challenge is to support MDE tooled-up process definition, implementation, assembly, and deployment all the while addressing industrial concerns for adaptability, maintainability and scalability. A second challenge is to be able to introduce MDE innovations in existing development processes at mastered cost, all the while managing the legacy.The MIRROR Pilot Program was launched three years ago in THALES to address these challenges. The concept of MDE methodological component was identified as a building block for supporting the definition and building of MDE tooled-up processes. An implementation approach for this concept is developed here within the context of a THALES industrial case, based on an extension of the IEEE Recommended practice for architectural description of software-intensive systems, IEEE Std 1471-2000.

The aim of this article is to describe a method that helps analysts to translate qualitative data gathered in the field, collected for the purpose of requirements specification, to a model usable for software engineers. Requirements specification constitutes three different parts: functional requirements, quality requirements, and nonfunctional requirements. The first one specifies how the software system should function, who are the actors, and what are the input and output of the functions. The second one specifies what quality requirements the software should meet while operating in context of its environment such as reliability, usability, efficiency, portability, and maintainability. Finally, the third part specifies other requirements including context of use and development constraints. Examples of context of use are where and when the system is used, and examples of development constraints are human resources, cost and time constraints, technological platforms, and development methods. The role of the requirements specification is to give software engineers a basis for software design, and, later in the software development life cycle, to validate the software system. Requirements specification can also serve the purpose of validating users’ or customers’ view of the requirements of the system. On one hand, there has been a growing trend towards analyzing needs of the user and abilities through participatory design (Kuhn & Muller, 1993), activity theory (Bertelsen & Bødker, 2003), contextual design (Beyer & Holtzblatt, 1998), user-centered design (Gulliksen, Göransson, & Lif, 2001), and co-design and observation as in ethnography (Hughes, O’Brien, Rodden, Rouncefield, & Sommerville, 1995). Common to these methods is that qualitative data (Taylor & Bogdan, 1998) is collected, to understand the future environment of the new system, by analyzing the work or the tasks, their frequency and criticality, the cognitive abilities of the user and the users’ collaborators. The scope of the information collected varies depending on the problem, and sometimes it is necessary to gather data about the regulatory, social, and organizational contexts of the problem (Jackson, 1995) to be solved. The temporal and spatial contexts describe when the work should be carried out and where. On the other hand, software engineers have specified requirements in several different modelling languages that range from semiformal to formal. Examples of semiformal languages are UML (Larman, 2002), SADT, and IDEF (Ross, 1985). Examples of the latter are Z (Potter, Sinclair, & Till, 1996), VDM or ASM. Those are modelling languages for software development, but some languages or methods focus on task or work modelling such as Concurrent Task Trees (Paterno, 2003) and Cognitive Work Analysis (Vicente, 1999). Others emphasize more the specification method than a modelling language. Examples of the former are Scenario-Based Design (SBD) (Rosson & Carroll, 2002) and Contextual Design (Beyer & Holtzblatt, 1998). In practice, many software developers use informal methods to express requirements in text, e.g., as narrations or stories. Agile Development Methods (Abrahamsson, Warsta, Siponen, & Ronkainen, 2003) emphasize this approach and thereby are consistent with their aim of de-emphasizing methods, processes, and languages in favor of getting things to work. A popular approach to requirements elicitation is developing prototypes. There has been less emphasis on bridging the gap between the above two efforts, for example, to deliver a method that gives practical guidelines on how to produce specifications from qualitative data (Hertzum, 2003). One reason for this gap can be that people from different disciplines work on the two aspects, for example, domain analysts or experts in HCI, and software engineers who read and use requirements specification as a basis for design. Another reason for this gap may be in the difference in the methods that the two sides have employed, that is, soft methods (i.e., informal) for elicitation and analysis and hard methods (i.e., formal) for specification. In this article, we suggest a method to translate qualitative data to requirements specification that we have applied in the development of a Smart Space for Learning. The process borrows ideas from or uses scenarios, interviews, feature-based development, soft systems methodology, claims analysis, phenomenology, and UML.

During the last decade, Model Driven Engineering (MDE) has been proposed for supporting the development, maintenance and evolution of software systems. Model Driven Architecture (MDA), Software Factories and Eclipse Modeling Framework (EMF) are among the most representatives MDE approaches. Nowadays, it is well recognized that model transformation is at the heart of MDE approaches and, consequently represents one of the most important operations in MDE. However, despite the multitude of model transformation language proposals emerging from academic world and industry, these transformations are often manually specified; which is a tedious and error-prone task, and therefore an expensive process. Matching operation between metamodels is the keystone toward a (semi-)automatic transformation process. In this paper, the authors review metamodel matching techniques of the literature and then analyze their pros and cons in order to show how they can be useful for a semi-automatic transformation process. The result is a comparison of metamodel matching techniques, highlighting their similarities and differences in terms of information used for matching, demonstrating significant similarities between these techniques. Next, the authors compare four well-known metamodel matching techniques namely Similarity flooding, SAMT4MDE+ (extended Semi-Automatic Matching Tool for Model Driven Engineering), ModelCVS and AML (AtlanMod Matching Language) on ten couples of metamodels. For this comparison, the authors define a set of six criteria inspired from the database schema matching. One among these criteria is relevant to the quality of matching and for which we define a quality measure metrics. Furthermore, the authors develop a plug-in under Eclipse to support our comparison using ten couples of metamodels.

Model-driven engineering (MDE) is a software engineering discipline focusing on models as the primary artifacts in the software development process while programs are mainly generated by means of model-to-code transformations. In particular, modeling languages tailored to specific application domains promise to increase the productivity and quality of software development. Nevertheless due to e.g. evolving requirements, modeling languages and their meta-models evolve which means that existing models have to be migrated correspondingly. In our approach, such co-evolutions are specified as related graph transformations ensuring well-typed model migration results. Based on our earlier work on co-transformations, we now consider the automatic deduction of migration rule schemes from given meta-model evolution rules. Rule schemes form the basis for user customizations on a high abstraction level. A rule scheme deduction algorithm is presented and several customized migration schemes for different co-evolution examples are discussed.

The Nordic Workshop on Model Driven Software Engineering brings together industry practitioners and academic researchers to share experiences and latest research on model driven software engineering and development. The workshop is a forum to present experiences and ongoing research in software engineering and model-driven engineering in particular, but also functions as an event for establishing co-operative research projects between the participants and working on joint research papers. The workshop provides an open forum, reserving ample time for discussions. The workshop has 7 editions of past history. Prior instances were held in Reykjavik (Island), Ronneby (Sweden), Grimstad (Norway), Tampere (Finland), and Turku (Finland).

The existing software engineering seldom considers software usability, and human-computer interaction (HCI) techniques which can improve the software usability cannot guarantee development efficiency. Recently, more and more stakeholders and users begin to regard the usability as an important software requirement. In order to bring respective advantages of software engineering and HCI techniques into full play to improve software usability and development efficiency, the paper presents user model driven software development, which integrates HCI techniques into software development method by eliciting user model under the participation of user, HCI designer and software engineer. Applications show that the method can be effectively applied to small software development team, and can raise software usability and development efficiency.

This paper details the application of software product lines (SPL) and model-driven engineering (MDE) to the software defined radio domain. More specifically it is an experience report emphasizing the synergy resulting from combining MDE and SPL technologies. The software defined radio domain has very unique characteristics as its systems typically are a confluence of a number of typically challenging aspects of software development. To name a few, these systems are usually described by modifiers such as, embedded, real-time, distributed, object-oriented, portable, heterogeneous, multithreaded, high performance, dynamic, resource-constrained, safety-critical, secure, networked, component based and fault-tolerant. Each one of these modifiers by themselves carries with it a set of unique challenges but building systems characterized by all of these modifiers all at the same time makes for quite an adventure in software development. In addition to all of these, it is quite common in these embedded systems for components to have multiple implementations that must run on disparate processing elements. With all of this taken into account, it stands to reason that these systems could and should benefit greatly from advances in software technology such as product line engineering, domain-specific modeling and model-driven engineering. It is our experience that one big boon to the software development industry is the combination of the software product lines and model driven engineering technologies.

Putting Requirements and Quality at the Core of Global Service Delivery: Current Efforts and Future Plans at Pace University

The capability of an enterprise to innovate and promptly and effectively respond to change requests coming from both internal and external drivers has nowadays become a measure of the competitiveness of the enterprise in all business sectors. Innovation often implies modifying the enterprise business processes and, as a consequence, requires the evolution of the enterprise software systems. In this context, the workshop on Evolution of Software Systems in a Business Context (ESSBC), held in Budapest, Hungary, as part of the IEEE Software Technology and Engineering Practice workshop series (STEP 2005), aimed at discussing experiences and research outcomes and identifying research issues in supporting the evolution of enterprise software systems to reach innovation goals

<p dir="ltr">Model-Driven Engineering (MDE) is a methodology in software development which emphasizes the use of models throughout the development process. Key aspects of MDE include process modelling and enactment, which provide a systemic approach to developing software. Traceability is currently gaining prominence within MDE, since it facilitates the tracking of artefacts through the development and management process, from inception to final output.</p><p dir="ltr">We propose an approach that integrates end-to-end traceability with process modelling. In our research, process models represent MDE workflows that span platform-independent modelling, platform-specific modelling, and code generation phases. Process execution is automated using megamodels and model transformation chains. The generation of end-to-end traceabillity information enables global model traceability, from high-level input models to generated code, forming the basis for traceability analysis.</p><p dir="ltr">We have built an Eclipse-based framework, ProMoTA, to support our approach. ProMoTA extends the Acceleo model transformation language, introducing local traceability support. Our tool suite within ProMoTA encompasses a global traceability map generator and end-to-end traceability analysis modules, providing users with a holistic view of the entire transformation process. To validate the efficacy and versatility of ProMoTA, we modelled and analyzed two distinct systems; a Digital Signal Processing Filter Designer which we both implemented and analyzed, and a WSNbased IoT system which we analyzed. Through analysis using our framework, we demonstrate ProMoTA’s capability to effectively address traceability challenges, underscoring its potential as a tool in modern MDE processes. In particular, ProMoTA allows us to examine global traceability of large systems and processes using change impact and origin tracking analysis techniques.</p>