Abstract Generative artificial intelligence (AI) is boosting the use of LLM-based conversational assistants in many domains. In software engineering, numerous integrated development environments (IDEs) offer conversational assistants to improve productivity, leading to AI-IDEs. However, the integration of assistants into IDEs is often ad-hoc, rigid and opaque. Moreover, the assistant-generated code is frequently untraceable, and developers struggle to trust it. Given the diversity of software construction processes, AI-IDE architectures should be: (i) open , permitting the on-demand configuration of assistive tasks, and enabling the coordination of assistants potentially built atop diverse LLMs; (ii) accountable , tracing the assistant contributions and exploiting this information to obtain project insights; (iii) trustworthy , allowing the customisation of safeguard protocols for the assistive tasks. To fill this gap, we propose an open, extensible, accountable architecture for AI-IDEs, which incorporates validation loops for trustworthy assistance. We have implemented this architecture as an extensible plugin for Java development within Eclipse, called Caret . We have conducted offline evaluations and a user study, which demonstrate that Caret can be easily extended with new tasks, and its handling of context and validation loops results in effectiveness improvements up to 147.34% compared to the baseline. Overall, our architecture facilitates the seamless integration of LLM-based conversational assistants into IDEs, coping with new assistive demands for specific needs, offering detailed accountability of development contributions, and incorporating configurable validation loops for trustworthy development.

Context: Metamorphic testing (MT) is a well-known approach to address the oracle problem in software testing. It does so by using expected relations – called metamorphic relations (MRs) – between the inputs and outputs of multiple system executions as test oracles. This approach involves identifying meaningful MRs for the domain, defining them in an executable language, and creating suitable system inputs to check their satisfaction. However, these tasks are manual and demand substantial effort from testers. Objective: To reduce the effort of applying MT, we propose automating some tasks in the MT process with intelligent assistants, focussing on MR inference and generation of follow-up test cases. Methods: We propose a taxonomy of MT tasks amenable to LLM-based assistance, and an extensible architecture for their automation. The MT tasks are accessible via a conversational assistant, and may encompass validation and fixing cycles to improve the quality of the assistance. We have integrated the architecture with the MT framework Gotten . Results: We have evaluated our approach on the two considered MT tasks across three domains (data centres, autonomous vehicles, finite automata). We found the assistant effective at generating new MRs (between 2 and 6 depending on the domain) and follow-up test cases (with over 99.6% correctness). We also measured diversity and redundancy of the generated MRs, the benefits of fixing cycles on different LLMs when generating follow-up test cases, and performance degradation and computational cost as input complexity increases. Conclusions: Our architecture effectively automates two central MT tasks, namely, inferring MRs and generating follow-up test cases, showing potential to reduce the effort from MT practitioners and to automate other MT tasks.

The advances in generative artificial intelligence, especially Large Language Models (LLMs), have prompted the proliferation of conversational agents (or chatbots). These can be general-purpose – like ChatGPT – or tailored to specific tasks – like buying tickets or obtaining customer support. Although chatbots play a significant role in today’s software ecosystem, they are hard to test: defining meaningful, thorough tests is time-consuming, and setting an oracle flexible to conversational variations is challenging. This is aggravated when testing LLM-based chatbots, as their conversation is natural but unpredictable. To alleviate this problem, we present an end-to-end testing approach for conversational agents, comprising two components. First, a highly customisable user simulator that generates meaningful conversations with a chatbot under test, for the given goals (e.g., setting an appointment) and communication styles (e.g., long/short phrases, spelling mistakes). Second, a domain-specific language to specify and check correctness conditions (assertions and metamorphic relations) on the generated conversations. The conditions can assess functional correctness (e.g., booking more tickets costs more) and interaction styles (e.g., the chatbot responds in English and does not deviate from certain topics). This paper describes the approach, an implementation enabling chatbots’ testing independently of their technology, and an evaluation of its effectiveness in finding defects. We tested our tool on chatbots with artificially injected errors, and on third-party, real-world chatbots. Our tool detected between 81.25% and 100% of the injected errors, and identified actual functional issues in the real-world chatbots by applying manually defined correctness rules.

Chatbots are popular to access all sorts of software services via natural language conversation. The increasing demand for task-oriented chatbots has triggered the proposal of many tools for their construction, like Dialogflow, Lex, Rasa, or Watson. However, selecting the most appropriate one is difficult; the conceptual design behind a chatbot may become buried under the tool technicalities; and migration between chatbot development platforms must be done manually. To alleviate these problems, we propose a platform-independent design notation for task-oriented chatbots, based on the analysis of fifteen chatbot development platforms. Following model-driven engineering principles, the chatbot implementation is synthesised from the design, and designs can be extracted from the implementations, enabling the migration and re-engineering of chatbots. Moreover, a recommender suggests the most suitable platform for a given chatbot design, considering contextual factors. We have realised these ideas in Conga : an extensible web application featuring a design notation editor; a development platform recommender; platform-specific validators; and generators and parsers for Dialogflow and Rasa. We evaluated Conga over 291 Dialogflow and Rasa open-source chatbots, showing its expressiveness, portability, and usefulness for finding chatbot quality issues (found in 93,8% of the chatbots). Overall, our architecture enables neutral chatbot designs, automates migration, and provides mechanisms for defect detection at the design level.

Abstract Model transformation plays an essential role in model-driven engineering. Models need to be transformed into other languages (e.g. for analysis) or rewritten (e.g. for optimisation or simulation). Specialised languages like ATL, ETL or QVT were designed for these tasks and became popular decades ago. However, looking at trends in academic venues and open-source repositories, we observe that their popularity has decayed in the last few years. This paper provides a retrospective on model transformation languages, analyses their current state in scientific venues and development platforms, and discusses possible reasons for their recent decline in popularity. Moreover, in light of current trends in AI-assisted development, we outline new research directions where model transformation languages can play a pivotal role, paving the way for their renewed adoption.

Abstract The need to produce software quicker and in greater quantities continues to grow, while the market for professional programmers struggles to meet the rising demand. Low-code development platforms (LCDPs) have been proposed as a solution that enables individuals without formal training to develop applications. However, current LCDPs typically rely on proprietary, fixed code generation processes, which limit flexibility, hinder interoperability, and risk vendor lock-in. To address these limitations, this paper introduces Dandelion+, a cloud-based low-code platform designed to create domain-specific LCDPs and applications within them. Our approach is highly model-driven, from defining the scaffolds of low-code platforms (e.g., models, meta-models, users, and roles) to creating applications. In particular, applications are powered by PlatFlow , a platform-aware graphical workflow language. Comprising both model operations and low-code-focused nodes, PlatFlow offers flexible control over the code generation process that drives LCDPs. We conduct two case studies to evaluate our approach. First, we confront Dandelion+ with other low-code platforms to design interactive applications and produce artifacts. Second, we report on the benefits of Dandelion+ in the industrial context of UGROUND, a Spanish software firm that uses low code in its projects.

Abstract Modelling languages are intensively used in paradigms like model-driven engineering to automate all tasks of the development process. These languages may have variants, in which case the need arises to deal with language families rather than with individual languages. However, specifying the syntax and semantics of each language variant separately in an enumerative way is costly, hinders reuse across variants, and may yield inconsistent semantics between variants. Hence, we propose a novel, modular and compositional approach to describing product lines of modelling languages. It enables the incremental definition of language families by means of modules comprising meta-model fragments, graph transformation rules, and rule extensions. Language variants are configured by selecting the desired modules, which entails the composition of a language meta-model and a set of rules defining its semantics. This paper describes: a theory for checking well-formedness, instantiability, and consistent semantics of all languages within the family; an implementation as an Eclipse plugin; and an evaluation reporting drastic specification size and analysis time reduction in comparison to an enumerative approach.

Modelling languages are heavily used in many disciplines, including software engineering. However, current languages are rigid , since they do not get adapted to fit the users’ expertise, the modelling task or the usage platform. This may turn some languages unsuitable for a range of users (from unexperienced to experts), goals (from informal discussion to precise specification) and platforms (from desktops to mobile phones). We claim that making languages adaptive to the modelling scenario would alleviate these issues and help simplifying recurring tasks such as language evolution or inter-operability between the languages of a family. In this article, we propose the new notion of adaptive modelling language . This concept combines meta-modelling and product lines to support variants of a given language, and encompasses contextual conditions triggering language reconfigurations, and mechanisms for model migration across the language variants. The article presents a theory and its realisation atop the Eclipse Modelling Framework. Our tool includes an Eclipse workbench to specify adaptive languages and produce Eclipse modelling editors with adaptation support. We report on an evaluation demonstrating the advantages of using our framework to express migrations across the variants of adaptive languages, which moreover have generally fast execution times.

Conversational agents - or chatbots - are increasingly used as the user interface to many software services. While open-domain chatbots like ChatGPT excel in their ability to chat about any topic, task-oriented conversational agents are designed to perform goal-oriented tasks (e.g., booking or shopping) guided by a dialogue-based user interaction, which is explicitly designed. Like any kind of software system, task-oriented conversational agents need to be properly tested to ensure their quality. For this purpose, some tools permit defining and executing conversation test cases. However, there are currently no established means to assess the coverage of the design of a task-oriented agent by a test suite, or mechanisms to automate quality test case generation ensuring the agent coverage.

Conversational agents, or chatbots, are increasingly used to access all sorts of services using natural language. While open-domain chatbots – like ChatGPT – can converse on any topic, task-oriented chatbots – the focus of this paper – are designed for specific tasks, like booking a flight, obtaining customer support, or setting an appointment. Like any other software, task-oriented chatbots need to be properly tested, usually by defining and executing test scenarios (i.e., sequences of user-chatbot interactions). However, there is currently a lack of methods to quantify the completeness and strength of such test scenarios, which can lead to low-quality tests, and hence to buggy chatbots.

The recent advances in generative artificial intelligence are revolutionising our daily lives. Large language models (LLMs) – the technology underlying conversational agents like ChatGPT – can produce sensible text in response to user prompts, and so, they are being used to solve tasks in many disciplines like marketing, law, human resources or media content creation. Software development is also following this trend, with recent proposals for conversational assistants tailored for this domain. However, there is still a need to understand the possibilities of integrating these assistants within integrated development environments (IDEs), coordinating multiple assistants, and tracing their contributions to the software project under development. This paper tackles this gap by exploring alternatives for assistant integration within IDEs, and proposing a general architecture for conversational assistance in software development that comprises a rich traceability model of the user-assistant interaction, and a multi-assistant coordination model. We have realised our proposal building an assistant (named CARET) for Java development within Eclipse. The assistant supports tasks like code completion, documentation, maintenance, code comprehension and testing. We present an evaluation for one specific development task (method renaming), showing promising results

Modelling languages are essential in many disciplines to express knowledge in a precise way. Furthermore, some domains require families of notations (rather than individual languages) that account for variations of a language. Some examples of language families include those to define automata, Petri nets, process models or software architectures. Several techniques have been proposed to engineer families of languages, but they often neglect the language's concrete syntax, especially if it is graphical.

Abstract Recommender systems (RSs) are ubiquitous in all sorts of online applications, in areas like shopping, media broadcasting, travel and tourism, among many others. They are also common to help in software engineering tasks, including software modelling, where we are recently witnessing proposals to enrich modelling languages and environments with RSs. Modelling recommenders assist users in building models by suggesting items based on previous solutions to similar problems in the same domain. However, building a RS for a modelling language requires considerable effort and specialised knowledge. To alleviate this problem, we propose an automated, model-driven approach to create RSs for modelling languages. The approach provides a domain-specific language called Droid to configure every aspect of the RS: the type of the recommended modelling elements, the gathering and preprocessing of training data, the recommendation method, and the metrics used to evaluate the created RS. The RS so configured can be deployed as a service, and we offer out-of-the-box integration with Eclipse modelling editors. Moreover, the language is extensible with new data sources and recommendation methods. To assess the usefulness of our proposal, we report on two evaluations. The first one is an offline experiment measuring the precision, completeness and diversity of recommendations generated by several methods. The second is a user study – with 40 participants – to assess the perceived quality of the recommendations. The study also contributes with a novel evaluation methodology and metrics for RSs in model-driven engineering.

Conversational agents, or chatbots, have become popular to access all kind of software services. They provide an intuitive natural language interface for interaction, available from a wide range of channels including social networks, web pages, intelligent speakers or cars. In response to this demand, many chatbot development platforms and tools have emerged. However, they typically lack support to statically measure properties of the chatbots being built, as indicators of their size, complexity, quality or usability. Similarly, there are hardly any mechanisms to compare and cluster chatbots developed with heterogeneous technologies. To overcome this limitation, we propose a suite of 21 metrics for chatbot designs, as well as two clustering methods that help in grouping chatbots along their conversation topics and design features. Both the metrics and the clustering methods are defined on a neutral chatbot design language, becoming independent of the implementation platform. We provide automatic translations of chatbots defined on some major platforms into this neutral notation to perform the measurement and clustering. The approach is supported by our tool Asymob , which we have used to evaluate the metrics and the clustering methods over a set of 259 Dialogflow and Rasa chatbots from open-source repositories. The results open the door to incorporating the metrics within chatbot development processes for the early detection of quality issues, and to exploit clustering to organise large collections of chatbots into significant groups to ease chatbot comprehension, search and comparison.

Many recommenders for modelling tasks have recently appeared. They use a variety of recommendation methods,tailored to concrete modelling languages. Typically, recommenders are created as independent programs, and subsequently need to be integrated within a modelling tool, incurring in high development effort. Moreover, it is currently not possible to reuse a recommender created for a modelling language with a different notation, even if they are similar. To attack these problems, we propose a methodology to reuse and integrate recommenders into modelling tools. It considers four orthogonal dimensions: the target modelling language, the tool, the recommendation source, and the recommended items. To make homogeneous the access to arbitrary recommenders, we propose a reference recommendation service that enables indexing recommenders, investigating their properties, and obtaining recommendations likely coming from several sources. Our methodology is supported by IronMan, an Eclipse plugin that automates the integration of recommenders within Sirius and tree-based editors, and can bridge recommenders created for a modelling language for their reuse with a different one. We evaluate the power of the tool by reusing 2 recommenders for 4 different languages, and integrating them into 6 modelling tools.

Testing is essential to improve the correctness of software systems. Metamorphic testing (MT) is an approach especially suited when the system under test lacks oracles, or they are expensive to compute. However, building an MT environment for a particular domain (e.g., cloud simulation, model transformation, machine learning) requires substantial effort. Our goal is to facilitate the construction of MT environments for specific domains. We propose a model-driven engineering approach to automate the construction of MT environments. Starting from a meta-model capturing the domain concepts, and a description of the domain execution environment, our approach produces an MT environment featuring comprehensive support for the MT process. This includes the definition of domain-specific metamorphic relations, their evaluation, detailed reporting of the testing results, and the automated search-based generation of follow-up test cases. Our method is supported by an extensible platform for Eclipse, called Gotten. We demonstrate its effectiveness by creating an MT environment for simulation-based testing of data centres and comparing with existing tools; its suitability to conduct MT processes by replicating previous experiments; and its generality by building another MT environment for video streaming APIs. Gotten is the first platform targeted at reducing the development effort of domain-specific MT environments. The environments created with Gotten facilitate the specification of metamorphic relations, their evaluation, and the generation of new test cases.

Petri nets are commonly used to represent concurrent systems. However, they lack support for modelling and analysing system families, like variants of controllers, different variations of a process model, or the possible configurations of a flexible assembly line. To facilitate modelling potentially large collections of similar systems, in this paper, we enrich Petri nets with variability mechanisms based on product line engineering. Moreover, we present methods for the efficient analysis of the place and transition invariants in all defined versions of a Petri net. Efficiency is achieved by analysing the system family as a whole, instead of analysing each possible net variant separately. For this purpose, we lift the notion of incidence matrix to the product line level, and rely on constraint solving techniques. We present tool support and evaluate the benefits of our techniques on synthetic and realistic examples, achieving in some cases speed-ups of two orders of magnitude with respect to analysing each net variant separately.

Creating and grading exercises are recurring tasks within higher education. When these exercises are based on diagrams – like logic circuits, automata or class diagrams – we can represent them as models, and use model-driven engineering techniques for the large-scale generation of quizzes, which can be automatically graded. This way, we propose a domain-independent tool for the generation and automated evaluation of diagram-based exercises called Wodel-Edu. Wodel-Edu is built atop Wodel, an extensible tool for model mutation, and offers seven kinds of diagram exercises. It supports code generation from the exercises for the Moodle platform, the web, Android and iOS applications. Evaluations from the professor and student perspectives show good results.

Recommender systems (RSs) are increasingly being used to help in all sorts of software engineering tasks, including modelling. However, building a RS for a modelling notation is costly. This is especially detrimental for development paradigms that rely on domain-specific languages (DSLs), like model-driven engineering and lowcode approaches.

Behavioral models are important assets that must be thoroughly verified early in the design process. This can be achieved with manually-written test cases that embed carefully hand-picked domain-specific input data. However, such test cases may not always reach the desired level of quality, such as high coverage or being able to localize faults efficiently. Test amplification is an interesting emergent approach to improve a test suite by automatically generating new test cases out of existing manually-written ones. Yet, while ad-hoc test amplification solutions have been proposed for a few programming languages, no solution currently exists for amplifying the test cases of behavioral models.

Modelling languages are intensively used in paradigms like model-driven engineering to automate all tasks of the development process. These languages may have variants, in which case the need arises to deal with language families rather than with individual languages. However, specifying the syntax and semantics of each language variant separately is costly, hinders reuse across variants, and may yield inconsistent semantics between variants.

Petri nets are a popular formalism to model and analyse concurrent systems.They can be combined with software product lines to support the specification of concurrent system families, like variants of controllers, process models, or configurations of flexible assembly lines.Specifically, a Petri net product line (PNPL) comprises a (black and white) Petri net decorated with variability inscriptions, and a feature model controlling the derivation of admissible nets of the family.However, the derivable nets cannot be reconfigured at runtime, and the techniques to analyse properties of such reconfigurations are limited.To tackle these issues, we present a method to embed a PNPL into a standard Coloured Petri net.This embedding permits using the extensive simulation and analysis capabilities of powerful tools like CPN Tools, and enables the reconfiguration of the product nets at run-time.In this paper, we report on the translation of PNPLs into Coloured Petri nets, characterize the properties that can be analysed with this translation, and describe tool support on the basis of a case study in the area of flexible production systems.

Abstract Recommender systems are information filtering systems used in many online applications like music and video broadcasting and e-commerce platforms. They are also increasingly being applied to facilitate software engineering activities. Following this trend, we are witnessing a growing research interest on recommendation approaches that assist with modelling tasks and model-based development processes. In this paper, we report on a systematic mapping review (based on the analysis of 66 papers) that classifies the existing research work on recommender systems for model-driven engineering (MDE). This study aims to serve as a guide for tool builders and researchers in understanding the MDE tasks that might be subject to recommendations, the applicable recommendation techniques and evaluation methods, and the open challenges and opportunities in this field of research.

Abstract The last few years have witnessed a significant growth of so-called low-code development platforms (LCDPs) both in gaining traction on the market and attracting interest from academia. LCDPs are advertised as visual development platforms, typically running on the cloud, reducing the need for manual coding and also targeting non-professional programmers. Since LCDPs share many of the goals and features of model-driven engineering approaches, it is a common point of debate whether low-code is just a new buzzword for model-driven technologies, or whether the two terms refer to genuinely distinct approaches. To contribute to this discussion, in this expert-voice paper, we compare and contrast low-code and model-driven approaches, identifying their differences and commonalities, analysing their strong and weak points, and proposing directions for cross-pollination.

3 states that "Codebots [7] uses UML to specify domain models that are consumed to automatically generate target artefacts, including complete REST APIs, client libraries, Swagger API documentation, and a JSON Schema definition for each domain object."

Software engineering uses models throughout most phases of the development process. Models are defined using modelling languages. To make these languages applicable to a wider set of scenarios and customizable to specific needs, researchers have proposed using product lines to specify modelling language variants. However, there is currently a lack of efficient techniques for ensuring correctness with respect to properties of the models accepted by a set of language variants. This may prevent detecting problematic combinations of language variants that produce undesired effects at the model level. To attack this problem, we first present a classification of instantiability properties for language product lines. Then, we propose a novel approach to lifting the satisfiability checking of model properties of individual language variants, to the product line level. Finally, we report on an implementation of our proposal in theMerlintool, and demonstrate the efficiency gains of our lifted analysis method compared to an enumerative analysis of each individual language variant.

We are witnessing an increasing interest in building recommender systems (RSs) for all sorts of Software Engineering activities. Modelling is no exception to this trend, as modelling environments are being enriched with RSs that help building models by providing recommendations based on previous solutions to similar problems in the same domain. However, building a RS from scratch requires considerable effort and specialized knowledge. To alleviate this problem, we propose an automated approach to the generation of RSs for modelling languages. Our approach is model-based, and we provide a domain-specific language called Droid to configure every aspect of the RS (like the type and features of the recommended items, the recommendation method, and the evaluation metrics). The RS so configured can be deployed as a service, and we offer out-of-the-box integration of this service with the EMF tree editor. To assess the usefulness of our proposal, we present a case study on the integration of a generated RS with a modelling chatbot, and report on an offline experiment measuring the precision and completeness of the recommendations.

Two crucial aspects for the trustworthy utilization of domain-specific languages (DSLs) are their semantic correctness, and proper testing support for their users. Testing is frequently used to verify correctness, but is often done informally -- which may yield unreliable results -- and requires substantial effort for creating suitable test cases and oracles.

Abstract Modelling is an essential activity in software engineering. It typically involves two meta-levels: one includes meta-models that describe modelling languages, and the other contains models built by instantiating those meta-models. Multi-level modelling generalizes this approach by allowing models to span an arbitrary number of meta-levels. A scenario that profits from multi-level modelling is the definition of language families that can be specialized (e.g., for different domains) by successive refinements at subsequent meta-levels, hence promoting language reuse. This enables an open set of variability options given by all possible specializations of the language family. However, multi-level modelling lacks the ability to express closed variability regarding the availability of language primitives or the possibility to opt between alternative primitive realizations. This limits the reuse opportunities of a language family. To improve this situation, we propose a novel combination of product lines with multi-level modelling to cover both open and closed variability. Our proposal is backed by a formal theory that guarantees correctness, enables top-down and bottom-up language variability design, and is implemented atop the MetaDepth multi-level modelling tool.

Models are the central assets in model-driven engineering (MDE), as they are actively used in all phases of software development. Models are built using metamodel-based languages, and so objects in models are typed by a metamodel class. This typing is static, established at creation time, and cannot be changed later. Therefore, objects in MDE are closed and fixed with respect to the class they conform to, the fields they have, and the well-formedness constraints they must comply with. This hampers many MDE activities, like the reuse of model-related artefacts such as transformations, the opportunistic or dynamic combination of metamodels, or the dynamic reconfiguration of models. To alleviate this rigidity, we propose making model objects open so that they can acquire or drop so-called facets . These contribute with a type, fields and constraints to the objects holding them. Facets are defined by regular metamodels, hence being a lightweight extension of standard metamodelling. Facet metamodels may declare usage interfaces , as well as laws that govern the assignment of facets to objects (or classes). This article describes our proposal, reporting on a theory, analysis techniques, and an implementation. The benefits of the approach are validated on the basis of five case studies dealing with annotation models, transformation reuse, multi-view modelling, multi-level modelling, and language product lines.

Modelling is a fundamental activity in software engineering, which is often performed in collaboration. For this purpose, on-line tools running on the cloud are frequently used. However, recent advances in Natural Language Processing have fostered the emergence of chatbots, which are increasingly used for all sorts of software engineering tasks, including modelling. To evaluate to what extent chatbots are suitable for collaborative modelling, we conducted an experimental study with 54 participants, to evaluate the usability of a modelling chatbot called SOCIO, comparing it with the on-line tool Creately. We employed a within-subjects cross-over design of 2 sequences and 2 periods. Usability was determined by attributes of efficiency, effectiveness, satisfaction and quality of the results. We found that SOCIO saved time and reduced communication effort over Creately. SOCIO satisfied users to a greater extent than Creately, while in effectiveness results were similar. With respect to diagram quality, SOCIO outperformed Creately in terms of precision, while solutions with Creately had better recall and perceived success. However, in terms of accuracy and error scores, both tools were similar.

The description of families of production systems usually relies on the use of variability modelling. This aspect of modelling is gaining increasing interest with the emergence of Industry 4.0 to facilitate the product development as new requirements appear. As a consequence, there are several emerging modelling techniques able to apply variability in different domains. In this paper, we introduce an approach to establish product system families in AutomationML. Our approach is based on the definition of feature models describing the variability space, and on the assignment of presence conditions to AutomationML model elements. These conditions (de-)select the model elements depending on the chosen configuration. This way, it is possible to model a large set of model variants in a compact way using one single model. To realize our approach, we started from an existing EMF-based AutomationML workbench providing graphical modelling support. From these artifacts, we synthesized an extended graphical modelling editor with variability support, integrated with FeatureIDE. Furthermore, we validated our approach by creating and managing a production system family encompassing six scenarios of the Pick and Place Unit Industry 4.0 demonstrator.

Modelling is a central activity in many disciplines. It is typically performed with the support of modelling tools that run on desktop computers or laptops, i.e., in static settings. How-ever, some modelling scenarios require a faithful representation of the position of the model elements in the physical world. Such scenarios would benefit from the ability to model in mobility and exploit the data obtained from the sensors embedded in mobile devices. For this purpose, we propose a conceptual approach to positioning-based modelling based on the combination of a physical dimension (as provided by the sensors of mobile devices) and an ontological one (as provided by domain meta-models). We showcase different scenarios for these ideas, and present a prototype app - called METAPHORE - that runs on iOS devices and realizes these concepts.

Modelling is an essential activity in software engineering processes. It typically involves two meta-levels: one includes meta-models that describe modelling languages, and the other contains models built by instantiating those meta-models. Multi-level modelling generalizes this approach by allowing models to span an arbitrary number of meta-levels. A scenario that profits from multi-level modelling is the definition of language families that become specialized by successive refinements at subsequent meta-levels, hence promoting language reuse. This enables an open set of variability options for the possible specializations of a given language. However, multi-level modelling lacks the ability to express closed variability regarding the supported language primitives and their realizations. This limits the reuse opportunities of a language family. To improve this situation, we propose a novel combination of product lines with multi-level modelling to cover both open and closed variability. Our proposal is backed by a formal theory that guarantees correctness, and is implemented atop the MetaDepth multi-level modelling tool.

Model-based development approaches, such as Model-Driven Engineering (MDE), heavily rely on the use of modelling languages to achieve and automate software development tasks. To enable the definition of model variants (e.g., supporting the compact description of system families), one solution is to combine MDE with Software Product Lines. However, this is technically costly as it requires adapting many MDE artefacts associated to the modelling language -- especially the meta-models and graphical environments. To alleviate this situation, we propose a method for the automated injection of variability into graphical modelling languages. Given the meta-model and graphical environment of a particular language, our approach permits configuring the allowed model variability, and the graphical environment is automatically adapted to enable creating models with variability. Our solution is implemented atop the Eclipse Modeling Framework and Sirius, and synthesizes adapted graphical editors integrated with FeatureIDE.

The correctness of model transformations is crucial to obtain high-quality solutions in model-driven engineering. Testing is a common approach to detect errors in transformations, which requires having methods to assess the effectiveness of the test cases and improve their quality. Mutation testing permits assessing the quality of a test suite by injecting artificial faults in the system under test. These emulate common errors made by competent developers and are modelled using mutation operators. Some researchers have proposed sets of mutation operators for transformation languages like ATL. However, their suitability for an effective mutation testing process has not been investigated, and there is no automated mechanism to generate test models that increase the quality of the tests. In this paper, we use transformations created by third parties to evaluate the effectiveness ATL mutation operators proposed in the literature, and other operators that we have devised based on empirical evidence on real errors made by developers. Likewise, we evaluate the effectiveness of commonly used test model generation techniques. For the cases in which a test suite does not detect an injected fault, we synthesize test models able to detect it. As a technical contribution, we make available a framework that automates this process for ATL.

Mutation testing (MT) is a well-known technique to evaluate and improve the quality of a given test-suite. While several MT tools exist for traditional programming languages, there is no common method to take advantage of MT in the case of domain-specific languages (DSLs). The current MT tools for DSLs are created ad-hoc, incurring in a high cost.

Background: The use of chatbots has increased considerably in recent years.These are used in different areas and by a wide variety of users.Due to this fact, it is essential to incorporate usability in their development.Aim: Our objective is to identify the state of the art in chatbot usability and applied human-computer interaction techniques, to analyze how to evaluate chatbots usability.Method: A systematic mapping study has been conducted, searching the main scientific databases.The search retrieved 170 citations and 19 articles were retained as primary studies.Results: The works were categorized according to four criteria: usability techniques, usability characteristics, research methods and type of chatbots.Conclusions: Chatbot usability is a very incipient field of research, where the published studies are mainly surveys, usability tests, and rather informal experimental studies.Hence, it becomes necessary to perform more formal experiments to measure user experience, and exploit these results to provide usability-aware design guidelines.

Like any other software artifact, models evolve and need to be versioned. In the last few years, dedicated support for model versioning has been proposed to improve the default text-based versioning that version control systems offer. However, there is still the need to comprehend model differences in terms of the semantics of the modeling language. For this purpose, we propose a comprehensive approach that considers both abstract and concrete syntax, to express model differences in terms of the domain-specific language (DSL) used and define domain-specific semantics for specific difference patterns. The approach is based on the automatic extension of the DSL to enable the representation of changes, on the definition of rules to capture recurrent domain-specific difference patterns, and on the automatic adaptation of the graphical concrete syntax to visualize the differences. We present a prototype tool support and discuss its application on versioned models created by third parties.

Background: The use of chatbots has increased considerably in recent years. These are used in different areas and by a wide variety of users. Due to this fact, it is essential to incorporate usability in their development. Aim: Our objective is to identify the state-of-the-art in chatbot usability and applied human–computer interaction techniques, to analyze how to evaluate chatbot usability. Method: We have conducted a systematic mapping study, by searching the main scientific databases. The search retrieved 170 references and 21 articles were retained as primary studies. Results: The works were categorized according to four criteria: usability techniques, usability characteristics, research methods and type of chatbots. Conclusions: Chatbot usability is still a very incipient field of research where the published studies are mainly surveys, usability tests, and rather informal experimental studies. Hence, it becomes necessary to perform more formal experiments to measure user experience, and exploit these results to provide usability-aware design guidelines.

Model transformations are key elements of model-driven engineering, where they are used to automate the manipulation of models. However, they are typed with respect to concrete source and target meta-models, making their reuse for other (even similar) meta-models challenging. To improve this situation, we propose capturing the typing requirements for reusing a transformation with other meta-models by the notion of a typing requirements model (TRM). A TRM describes the prerequisites that a model transformation imposes on the source and target meta-models to obtain a correct typing. The key observation is that any meta-model pair that satisfies the TRM is a valid reuse context for the transformation at hand. A TRM is made of two domain requirement models (DRMs) describing the requirements for the source and target meta-models, and a compatibility model expressing dependencies between them. We define a notion of refinement between DRMs and see meta-models as a special case of DRM. We provide a catalogue of valid refinements and describe how to automatically extract a TRM from an ATL transformation. The approach is supported by our tool TOTEM. We report on two experiments—based on transformations developed by third parties and meta-model mutation techniques—validating the correctness and completeness of our TRM extraction procedure and confirming the power of TRMs to encode variability and support flexible reuse.

Model-Driven Engineering (MDE) is a software engineering paradigm where models are actively used to specify, test, simulate, analyse and maintain the systems to be built, among other activities. Models can be defined using general-purpose modelling languages like the UML, but for particular domains, the use of domain-specific languages is pervasive. Either way, models must conform to a meta-model which defines their abstract syntax.

Modelling is a fundamental activity in Software Engineering, and central to model-based engineering approaches. It is used for different purposes, and so its nature can range from informal (e.g., as a casual mechanism for problem discussion and understanding) to fully formal (e.g., to enable the automated processing of models by model transformations). However, existing modelling tools only serve one of these two extreme purposes: either to create informal drawings or diagrams, or to build models fully conformant to their modelling language. This lack of reconciliation is hampering the adoption of model-based techniques in practice, as they are deemed too imprecise in the former case, and too rigid in the latter.

Model transformations enable automation in Model-Driven Engineering (MDE) and are key to its success. The emphasis of MDE on using domain-specific languages has caused a proliferation of meta-models, many of them capturing variants of base languages. In this scenario, developing a transformation for a new meta-model is usually performed manually with no reuse, even if comparable transformations for similar meta-models exist. This is a suboptimal process that precludes a wider adoption of MDE in industry.

Model-driven engineering advocates the use of models to describe and automate many software development tasks. The syntax of modelling languages is defined by meta-models, making them essential artefacts. A combination of product line engineering methods and meta-models has been proposed to enable specification of modelling language variants, e.g., to describe a range of systems. However, there is a lack of techniques for ensuring syntactic correctness of all meta-models within a family (including their OCL constraints), and semantic correctness related to properties of individual instances of the different variants. The absence of verification methods at the product-line level can cause synthesis of ill-formed meta-models and problematic feature combinations whose effect at the instance level may go unnoticed.

Model-driven engineering (MDE) promotes models as the principal assets in software projects. Models are built using a modelling language whose syntax is defined by a metamodel. Hence, objects in models are typed by a metamodel class, and this typing relation is static as it is established at creation time and cannot be changed later. This way, objects in MDE are closed and fixed with respect to the type they conform to, the slots/properties they have, and the constraints they should obey. This hampers the reuse of model-related artefacts like model transformations, as well as the opportunistic or dynamic combination of metamodels.

Model-Driven Engineering (MDE) uses models as its main assets in the software development process. The structure of a model is described through a meta-model. Even though modelling and meta-modelling are recurrent activities in MDE and a vast amount of MDE tools exist nowadays, they are tasks typically performed in an unassisted way. Usually, these tools cannot extract useful knowledge available in heterogeneous information sources like XML, RDF, CSV or other models and meta-models. We propose an approach to provide modelling and meta-modelling assistance. The approach gathers heterogeneous information sources in various technological spaces, and represents them uniformly in a common data model. This enables their uniform querying, by means of an extensible mechanism, which can make use of services, e.g., for synonym search and word sense analysis. The query results can then be easily incorporated into the (meta-)model being built. The approach has been realized in the Extremo tool, developed as an Eclipse plugin. Extremo has been validated in the context of two domains – production systems and process modelling – taking into account a large and complex industrial standard for classification and product description. Further validation results indicate that the integration of Extremo in various modelling environments can be achieved with low effort, and that the tool is able to handle information from most existing technological spaces.

Multi-level modelling promotes flexibility in modelling by enabling the use of several meta-levels instead of just two, as is the case in mainstream two-level modelling approaches. While this approach leads to simpler models for some scenarios, it introduces an additional degree of freedom as designers can decide the meta-level where an element should reside, having to ascertain the suitability of such decisions. In this respect, model refactorings have been successfully applied in the context of two-level modelling to rearrange the elements of a model while preserving its meaning. Following this idea, we propose a catalogue of 17 novel refactorings specific to multi-level models. Their objective is to help designers in rearranging elements across and within meta-levels and exploring the consequences. In this article, we detail each refactoring in the catalogue, show a classification across different dimensions, and describe the support we provide in our M eta D epth tool. We present two experiments to assess two aspects of our refactorings. The first one validates the predicted semantic side effects of the refactorings on the basis of more than 210.000 refactoring applications. The second one measures the impact of refactorings on three quality attributes of multi-level models.

We are witnessing a rising role of mobile computing and social networks to perform all sorts of tasks. This way, social networks like Twitter or Telegram are used for leisure, and they frequently serve as a discussion media for work-related activities. In this paper, we propose taking advantage of social networks to enable the collaborative creation of models by groups of users. The process is assisted by modelling bots that orchestrate the collaboration and interpret the users' inputs (in natural language) to incrementally build a (meta-)model. The advantages of this modelling approach include ubiquity of use, automation, assistance, natural user interaction, traceability of design decisions, possibility to incorporate coordination protocols, and seamless integration with the user's normal daily usage of social networks. We present a prototype implementation called SOCIO, able to work over several social networks like Twitter and Telegram, and a preliminary evaluation showing promising results.

Model transformations are used to automate model manipulation in Model-Driven Engineering (MDE). In particular, model-to-model transformations produce target models (conformant to a target meta-model) from source ones (conformant to a source meta-model). While transformation correctness is crucial in MDE, developing transformations is error-prone due to the difficulty in testing them. This problem is further aggravated if the source and target meta-models contain OCL integrity constraints, as every transformed source model should satisfy the target integrity constraints.In order to attack this problem, we present a novel method that translates target OCL constraints to the source meta-model using the transformation definition. This way, if a source model satisfies the advanced constraint, the transformed model will satisfy the target constraint. The method has been implemented for the ATL transformation language and integrated with the anATLyzer tool. We show its benefits in combination with model finders, and the promising results of its validation using mutation techniques and transformations developed by third parties.

Domain-specific languages (DSLs) are small languages tailored to a certain application area, like logistics, web application testing or smart city planning. Traditionally, the use of DSLs has been limited to a static setting in desktop or web editors. However, in this paper, we claim that DSLs can be central components of mobile collaborative applications. In our vision, graphical DSLs can be extended to make use of mobility and context, and integrate heterogeneous information gathered from open APIs. We call this new generation languages "active DSLs".We foresee a range of scenarios where active DSLs can be useful. On the one hand, they can be used more flexibly in remote locations by enabling local collaboration of several mobile devices using their short-range communication capabilities. On the other hand, they can be extended with contextual features like geolocation, allowing the integration of maps and geo-services within the DSL, or the DSL rendering customization in response to contextual information. Active DSLs can also retrieve information from open APIs, in which case, models defined with the DSL become aggregators of heterogeneous data.In this paper, we explain our vision for active DSLs and the first steps towards its realization in the DSL-comet tool. The tool permits creating and using mobile graphical DSLs on iOS devices, and their seamless use in desktop environments.

Designing data-centers that provide an acceptable costperformance ratio is challenging.Generally, a wide spectrum of components must be previously analyzed, such as the kind of applications to be executed in the data-center, computing/storage requirements and the network topology, among others.Since each one of these components has a direct impact on the overall system performance, the design process is complex and difficult, which usually requires the intervention of an expert.We propose a model-based approach to design datacenters.For this purpose, we have created a meta-model that describes the structure of data-center models.Then, a set of expert rules can be used to detect sub-optimal configurations, and (in some cases) correct the design.Datacenter models can be simulated, to assess their performance and scalability, for which we use a code generator into the SIMCAN tool.We have implemented our approach as an Eclipse plugin, and illustrate the usefulness of some expert rules by showing the efficiency and scalability gains of the optimized model with respect to the original one.

Model-Driven Engineering (MDE) is founded on the ability to create and process models conforming to a meta-model. In this context, classes in a meta-model are used in two ways: as templates to create objects and as (static) classifiers for them. These two aspects are inherently tied in most meta-modelling approaches, which results in unnecessarily rigid systems and hinders reusability of MDE artefacts. In this work, we discuss the benefits of decoupling object creation from typing in MDE. Thus, we rely on standard mechanisms for object creation, and proposea posteriorityping as a means to retype objects and enable multiple, partial, dynamic typings. This approach enhances flexibility; permits unanticipated reuse, as model management operations defined for a meta-model can be reused with other models once they get reclassified; and enables bidirectional model transformation by reclassification. In particular, we propose two mechanisms to realise model retyping and show their underlying theory and analysis methods. We show the feasibility of the approach by an implementation atop our meta-modelling tool MetaDepthand present several applications of retypings (transformations, reuse, and dynamicity).

Model transformations are central to Model-Driven Engineering (MDE), where they are used to transform models between different languages; to refactor and simulate models; or to generate code from models. Thus, given their prominent role in MDE, practical methods helping in detecting errors in transformations and automate their verification are needed. In this paper, we present a method for the static analysis of ATL model transformations. The method aims at discovering typing and rule errors, like unresolved bindings, uninitialized features or rule conflicts. It relies on static analysis and type inference, and uses constraint solving to assert whether a source model triggering the execution of a given problematic statement can possibly exist. Our method is supported by a tool that integrates seamlessly with the ATL development environment. To evaluate the usefulness of our method, we have used it to analyse a public repository of ATL transformations. The high number of errors discovered shows that static analysis of ATL transformations is needed in practice. Moreover, we have measured the precision and recall of the method by considering a synthetic set of transformations obtained by mutation techniques, and comparing with random testing. The experiment shows good overall results in terms of false positives and negatives.

Meta-models play a pivotal role in Model-Driven Engineering (MDE). They are used to create domain-specific models, and to type model management operations like model transformations or code generators. However, even though creating meta-models is a common activity, it is currently mostly a manual activity, which does not profit from existing knowledge. In order to facilitate the meta-modelling task, we propose an extensible meta-modelling assistant. While primarily focussed on helping in the creation of meta- models, it can also help in creating models. The assistant permits the provision of heterogeneous data description sources (like ontologies, RDF data, XML schemas, database schemas and meta-models), and enables their uniform querying. Different kinds of queries are supported, and improved through synonym search. Query results are prioritized through sense disambiguation, can be graphically visualized, and incorporated into the (meta-)model being built. The assistant has been realized within Eclipse, and its architecture has been designed to be independent of the meta-modelling technology used. As a proof- of-concept, we show its integration within DSL-tao, a pattern-based meta-modelling tool built by our group, and two other tools developed by third-parties. The usefulness of the system is illustrated with a running example in the process modelling domain.

Domain-Specific Languages (DSLs) are central to Model-Driven Engineering, where they are used for creating models for particular domains. However, current research and tools for building DSLs focus on the design and implementation aspects of the DSL, while the requirements analysis phase, and its automated transition to design is largely neglected.

Model-based development relies on models in different phases for different purposes, with modelling patterns being used to document and gather knowledge about good practices in specific domains, to analyse the quality of existing designs, and to guide the construction and refactoring of models. Providing a formal basis for the use of patterns would also support their integration with existing approaches to model transformation. To this end, we turn to the commonly used, in this context, machinery of graph transformations and provide an algebraic-categorical formalization of modelling patterns, which can express variability and required/forbidden application contexts. This allows the definition of transformation rules having patterns in left and right-hand sides, which can be used to express refactorings towards patterns, change the use of one pattern by a different one, or switch between pattern variants. A key element in our proposal is the use of operations to abstract models into patterns, so that they can be manipulated by pattern rules, thus leading to a rewriting mechanism for classes of graphs described by patterns and not just individual graphs. The proposal is illustrated with examples in object-oriented software design patterns and enterprise architecture patterns, but can be applied to any other domain where patterns are used for modelling.

Model-Driven Engineering (MDE) promotes models throughout development. However, models may become large and unwieldy even for small to medium-sized systems. This paper tackles the MDE challenges of model complexity and scalability. It proposes Fragmenta, a theory of modular design that breaks down overall models into fragments that can be put together to build meaningful wholes, in contrast to classical MDE approaches that are essentially monolithic. The theory is based on an algebraic description of models, fragments and clusters based on graphs and morphisms. The paper's novelties include: (i) a mathematical treatment of fragments and a seaming mechanism of proxies to enable inter-fragment referencing, (ii) fragmentation strategies, which prescribe a fragmentation structure to model instances, (iii) Fragmenta's support for both top-down and bottom-up design, and (iv) our formally proved result that shows that inheritance hierarchies remain well-formed (acyclic) globally when fragments are composed provided some local fragment constraints are met.

The correctness of model transformations is key to obtain reliable MDE solutions. However, current transformation tools provide limited support to statically detect and correct errors. This way, the identification of errors and their correction are mostly manual activities. Our aim is to improve this situation. Based on a static analyser for ATL model transformations which we have previously built, we present a method and a system to propose quick fixes for transformation errors. The analyser is based on a combination of program analysis and constraint solving, and our quick fix generation technique makes use of the analyser features to provide a range of fixes, notably some nontrivial, transformation-specific ones. Our approach integrates seamlessly with the ATL editor. We provide an evaluation based on an existing faulty transformation, and automatically generated transformation mutants, showing overall good results.

Model-Driven Engineering is founded on the ability to create and process models conformant to a meta-model. Hence, meta-model classes are used in two ways: as templates to create objects, and as classifiers for them. While these two aspects are inherently tied in most meta-modelling approaches, in this paper, we discuss the benefits of their decoupling. Thus, we rely on standard mechanisms for object creation and propose a-posteriori typing as a means to reclassify objects and enable multiple, partial, dynamic typings. This approach enhances flexibility, permitting unanticipated reutilization (as existing model management operations defined for a meta-model can be reused with other models once they get reclassified), as well as model transformation by reclassification. We show the underlying theory behind the introduced concepts, and illustrate its applicability using our MetaDepth meta-modelling tool.

Model-Driven Engineering (MDE) promotes the use of models to conduct all phases of software development in an automated way. Models are frequently defined using Domain- Specific Modelling Languages (DSMLs), which many times need to be developed for the domain at hand. However, while constructing DSMLs is a recurring activity in MDE, there is scarce support for gathering, reusing and enacting knowledge for their design and implementation. This forces the development of every new DSML to start from scratch. To alleviate this problem, we propose the construction of DSMLs and their modelling environments aided by patterns which gather knowledge of specific domains, design alternatives, concrete syntax, dynamic semantics and functionality for the modelling environment. They may have associated services, realized via components. Our approach is supported by a tool that enables the construction of DSMLs through the application of patterns, and synthesizes a graphical modelling environment according to them.

The definition of Domain-Specific Languages (DSLs) is a recurrent activity in Model-Driven Engineering. However, their construction is many times an ad-hoc process, partly due to the lack of tools enabling a proper engineering of DSLs and promoting domain experts to play an active role. The focus of this paper is on the validation of meta-models for visual DSLs. For this purpose, we propose a language and tool support for describing properties that instances of meta-models should (or should not) meet. Then, our system uses a model finder to produce example models, enriched with a graphical concrete syntax, that confirm or refute the assumptions of the meta-model developer. Our language complements metaBest, a framework for the validation and verification of meta-models that includes two other languages for unit testing and specification-based testing of meta-models. A salient feature of our approach is that it fosters interaction with domain experts by the use, processing and creation of informal drawings constructed in editors liked yED or Dia. We assess the usefulness of the approach in the validation of a DSL for house blueprints, with the participation of 26 4th year computer science students.

Model transformations play a prominent role in Model-Driven Engineering (MDE), where they are used to transform models between languages, to refactor and simulate models, or to generate code from models. However, while the reliability of any MDE process depends on the correctness of its transformations, methods helping in detecting errors in transformations and automate their verification are still needed. To improve this situation, we propose a method for the static analysis of one of the most widely used model transformation languages: ATL. The method proceeds in three steps. Firstly, it infers typing information from the transformation and detects potential errors statically. Then, it generates OCL path conditions for the candidate errors, stating the requirements for a model to hit the problematic statements in the transformation. Last, it relies on constraint solving to generate a test model fragment or witness that exercises the transformation, making it execute the problematic statement. Our method is supported by a prototype tool that integrates a static analyzer, a testing tool and a constraint solver. We have used the tool to analyse medium and large-size third-party ATL transformations, discovering a wide number of errors.

Meta-models play a cornerstone role in Model-Driven Engineering as they are used to define the abstract syntax of Domain-Specific Modelling Languages, and so models and all sorts of model transformations depend on them. However, there are scarce tools and methods supporting their validation and verification, which are essential activities for the proper engineering of meta-models.

Meta-modelling is one of the pillars of model-driven engineering (MDE), where it is used for language engineering and domain modelling. Even though the current trend is the use of two-level meta-modelling frameworks, several researchers have pointed out limitations of this scheme for some scenarios and suggested a meta-modelling approach with an arbitrary number of meta-levels in order to obtain more flexible and simpler system descriptions. Unfortunately, such multi-level meta-modelling systems are still in their infancy, lacking, for example, integration with model manipulation languages, a characterization of different possibilities for instantiation and inheritance and primitives for interconnecting multi-level languages in a flexible way. In the paper, we propose a number of extensions to multi-level (also called deep) meta-modelling, on the basis of the needs raised by its use for practical MDE. In particular, we discuss on the issues related to code generation from deep languages, the benefits of allowing inheritance at every meta-level and patterns and techniques for a fine-grain control of the meta-level of elements. Finally, we provide primitives to control the impedance mismatch when connecting models at different meta-levels.

Abstract Metamodelling is one of the pillars of model-driven engineering, used for language engineering and domain modelling. Even though metamodelling is traditionally based on a two-metalevel approach, several researchers have pointed out limitations of this solution and proposed an alternative deep (also called multi-level ) approach to obtain simpler system specifications. However, this approach currently lacks a formalisation that can be used to explain fundamental concepts such as deep characterisation, double linguistic/ontological typing and linguistic extension. This paper provides such a formalisation based on the Diagram Predicate Framework, and discusses its practical realisation in the metaDepth tool.

Model-Driven Engineering (MDE) promotes models as the primary artefacts in the software development process, from which code for the final application is derived. Standard approaches to MDE (like those based on MOF or EMF) advocate a two-level metamodelling setting where Domain-Specific Modelling Languages (DSMLs) are defined through a metamodel that is instantiated to build models at the metalevel below. Multilevel modelling (also called deep metamodelling ) extends the standard approach to metamodelling by enabling modelling at an arbitrary number of metalevels, not necessarily two. Proposers of multilevel modelling claim this leads to simpler model descriptions in some situations, although its applicability has been scarcely evaluated. Thus, practitioners may find it difficult to discern when to use it and how to implement multilevel solutions in practice. In this article, we discuss those situations where the use of multilevel modelling is beneficial, and identify recurring patterns and idioms. Moreover, in order to assess how often the identified patterns arise in practice, we have analysed a wide range of existing two-level DSMLs from different sources and domains, to detect when their elements could be rearranged in more than two metalevels. The results show this scenario is not uncommon, while in some application domains (like software architecture and enterprise/process modelling) pervasive, with a high average number of pattern occurrences per metamodel.

Model-driven engineering promotes an active use of models to conduct the software development process. In this way, models are used to specify, simulate, verify, test and generate code for the final systems. Model transformations are key enablers for this approach, being used to manipulate instance models of a certain modelling language. However, while other development paradigms make available techniques to increase productivity through reutilization, there are few proposals for the reuse of model transformations across different modelling languages. As a result, transformations have to be developed from scratch even if other similar ones exist. In this paper, we propose a technique for the flexible reutilization of model transformations. Our proposal is based on generic programming for the definition and instantiation of transformation templates, and on component-based development for the encapsulation and composition of transformations. We have designed a component model for model transformations, supported by an implementation currently targeting the Atlas Transformation Language (ATL). To evaluate its reusability potential, we report on a generic transformation component to analyse workflow models through their transformation into Petri nets, which we have reused for eight workflow languages, including UML Activity Diagrams, YAWL and two versions of BPMN.

The increasing popularity of Massive Open Online Courses (MOOCs) has raised the need for highly scalable, customizable, open learning environments. At the same time, there is a growing trend to open the services that the companies offer on the web with open APIs and in the form of REST services, facilitating their integration in customized applications. The goal of this work is to show how such open services can be used for the support of on-line educational systems. These services were not created for an education context, so it is necessary to complement it with functionalities for supporting aspects such as evaluations, monitoring or collaboration. This article discusses on the strategies for integrating services for education and presents two cases studies: first, SMLearning, a collaborative learning environment supported by social media platforms Facebook and YouTube, and second, an application for project-based programming courses, customized through a generative architecture, making heavy use of Google services.

In Model Driven Engineering (MDE) models are the main artefacts of the software development process. Model transformations are used both in the software development phase and for verification and simulation of the system behaviour. Hence, tools and languages for describing model transformations are essential in MDE. While many practical transformation languages and tools have been proposed, there is still the need for formal foundations of model transformations.

This is an electronic version of the paper presented at the 7th International Conference on Software Paradigm Trends, ICSOFT 2012, held in Rome.

QVT is the standard for model transformation defined by the OMG in the context of the Model-Driven Architecture. It is made of several transformation languages. Among them, QVT-Relations is the one with the highest level of abstraction, as it permits

In this paper, we present a questionnaire-driven collaborative design methodology for the automatic generation of collaborative applications. The methodology is based on a repository of collaborative components and a knowledge base of its application and use modes. The repository includes components

While interaction patterns are becoming widespread in the field of interface design, their definitions do not enjoy a common standard yet, as is for software patterns. Moreover, patterns are developed for diverse design aspects, reflecting the complexity of the field. As a consequence, research on formalization of interaction patterns is not developed, and few attempts have been made to extend techniques developed for design pattern formalization. We show here how an extension to our recent approach to pattern formalization can be usefully employed to formalize some classes of interaction patterns, to express relations among them, and to detect conflicts.

Model Driven Engineering promotes models as the core assets of projects and hence model transformations become first-class citizens in this approach. Likewise, the development of large scale transformations necessitates a systematic engineering process and supporting modelling notations. However, although many languages have been proposed to implement transformations, few allow their specification at a higher level of abstraction. In this paper we present a visual, formal, declarative specification language to express model-to-model transformations and their correctness properties. The language supports the two main approaches to model-to-model transformation -- trace-based and traceless -- with a unified formal semantics. Moreover, we provide a compilation of specifications into OCL as this has many practical applications, e.g. it allows injecting assertions and correctness properties for automated testing of transformation implementations based on OMG standards.

Domain Specific Visual Languages (DSVLs) play a cornerstone role in Model-Driven Engineering (MDE), where (domain specific) models are used to automate the production of the final application. Graph Transformation is a formal, visual, rule-based technique, which is increasingly used in MDE to express in-place model transformations like refactorings, animations and simulations. However, there is currently a lack of methods able to perform static analysis of rules, taking into account the DSVL meta-model integrity constraints. In this paper we propose a lightweight, efficient technique that performs static analysis of the weak executability of rules. The method determines if there is some scenario in which the rule can be safely applied, without breaking the meta-model constraints. If no such scenario exists, the method returns meaningful feedback that helps repairing the detected inconsistencies.

Abstract We present a novel approach for the automatic generation of model-to-model transformations given a description of the operational semantics of the source language in the form of graph transformation rules. The approach is geared to the generation of transformations from Domain-Specific Visual Languages (DSVLs) into semantic domains with an explicit notion of transition, like for example Petri nets. The generated transformation is expressed in the form of operational triple graph grammar rules that transform the static information (initial model) and the dynamics (source rules and their execution control structure). We illustrate these techniques with a DSVL in the domain of production systems, for which we generate a transformation into Petri nets. We also tackle the description of timing aspects in graph transformation rules, and its analysis through their automatic translation into Time Petri nets.

In the Matrix approach to graph transformation we represent simple digraphs and rules with Boolean matrices and vectors, and the rewriting is expressed using Boolean operators only. In previous works, we developed analysis techniques enabling the study of the applicability of rule sequences, their independence, state reachability and the minimal graph able to fire a sequence. In the present paper we improve our framework in two ways. First, we make explicit (in the form of a Boolean matrix) some negative implicit information in rules. This matrix (called nihilation matrix) contains the elements that, if present, forbid the application of the rule (i.e. potential dangling edges, or newly added edges, which cannot be already present in the simple digraph). Second, we introduce a novel notion of application condition, which combines graph diagrams together with monadic second order logic. This allows for more flexibility and expressivity than previous approaches, as well as more concise conditions in certain cases. We demonstrate that these application conditions can be embedded into rules (i.e. in the left hand side and the nihilation matrix), and show that the applicability of a rule with arbitrary application conditions is equivalent to the applicability of a sequence of plain rules without application conditions. Therefore, the analysis of the former is equivalent to the analysis of the latter, showing that in our framework no additional results are needed for the study of application conditions. Moreover, all analysis techniques of [21,22] for the study of sequences can be applied to application conditions.

This paper analyses the relationships between personality, team processes, task characteristics, product quality and satisfaction in software development teams. The data analysed here were gathered from a sample of 35 teams of students (105 participants) from a Spanish university. These teams applied an adaptation of an agile methodology, eXtreme Programming (XP), to develop the same software product.

We present a new approach - based on graph transformation - to incremental specification of the operational (execution) semantics of visual languages. The approach combines editing rules with two meta-models: one to define the concrete syntax and one for the static semantics. We introduce the notion of action patterns, defining basic actions (e.g. consuming or producing a token in transition-based semantics), in a way similar to graph transformation rules. The application of action patterns to a static semantics editing rule produces a meta-rule, to be paired with the firing of the corresponding syntactic rule to incrementally build an execution rule. An execution rule is thus tailored to any active element (e.g. a transition in a Petri net model) in the model. Examples from Petri nets, state automata and workflow languages illustrate these ideas.

This paper presents an agent-based model of an organization. The model is made of a social network—composed of the different organization workers—and a knowledge network. Workers are assigned tasks, for which they have to use information in the knowledge network. We have modeled the quality of the information by assigning each information item a probability of being wrong. Agents can interact with other agents, who can recommend to them new information items in the knowledge network for the task to be performed. Workers are assigned different information-seeking behavior (passive, active, and learning), governing the way in which they interact with each other. Moreover, indirect interaction is also possible, as a publicly accessible knowledge base contains each agent's preferred information items. The model was implemented in SDML, and its simulation shows that agents quickly learn to discern the better information items for the given task. However, group formation (agents' collaborating by exchanging information) takes longer to stabilize. Additionally, when the quality of items is changed, agents can quickly select the better new knowledge items, and organization performance improves again to a maximum that is only randomly disturbed.

In this paper we present a formal approach, based on meta-modelling and graph transformation, to the generation of environments for visual languages (VLs) supporting multiple views. The VL syntax is defined by means of a meta-model. Views for the VL are created by selecting the classes, associations, attributes and constraints that are part of them. Once the environment is generated, the view models are translated into a global, unique model where consistency checking and further analysis can be performed by means of graph grammars. These ideas have been newly implemented in the AToM/sup 3/ tool.