Detecting code clones is an established method for comprehending and maintaining systems. One important but challenging form of code clone detection involves detecting semantic clones, which are those that are semantically similar code segments that differ syntactically. Existing approaches to semantic clone detection do not scale well to large code bases and have room for improvement in their precision and recall. In this paper, we present a scalable slicing-based approach for detecting code clones, including semantic clones. We determine code segment similarity based on their corresponding program slices. We take advantage of a lightweight, publicly available, and scalable program slicing approach to compute the necessary information. Our approach uses dependency analysis to find and measure cloned elements, and provides insights into elements of the code that are affected by an entire clone set/class. We have implemented our approach as a tool called srcClone. We evaluate it by comparing it to two semantic clone detectors in terms of clones, performance, and scalability; and perform recall and precision analysis using established benchmark scenarios. In our evaluation, we illustrate our approach is both relatively scalable and accurate. srcClone can also be used by program analysts to run on non-compilable and incomplete source code, which serves comprehension and maintenance tasks very well. We believe our approach is an important advancement in program comprehension that can help improve clone detection practices and provide developers greater insights into their software.

Widespread and mature practice of model-driven engineering is leading to a growing number of modeling artifacts and challenges in their management. Model clone detection (MCD) is an important approach for managing and maintaining modeling artifacts. While its counterpart in traditional source code development, code clone detection, is enjoying popularity and more than two decades of development, MCD is still in its infancy in terms of research and tooling. We aim to develop a portal for model clone detection, MoCoP, as a central hub to mitigate adoption barriers and foster MCD research. In this short paper, we present our vision for MoCoP and its features and goals. We discuss MoCoP's key components that we plan on realizing in the short term including public tooling, curated data sets, and a body of MCD knowledge. Our longer term goals include a dedicated service-oriented infrastructure, contests, and forums. We believe MoCoP will strengthen MCD research, tooling, and the community, which in turn will lead to better quality, maintenance, and scalability for model-driven engineering practices.

Summary Model‐driven engineering is an increasingly prevalent approach in software engineering where models are the primary artifacts throughout a project's life cycle. A growing form of analysis and quality assurance in these projects is model clone detection, which identifies similar model elements. As model clone detection research and tools emerge, methods must be established to assess model clone detectors and techniques. In this paper, we describe the MuMonDE framework, which researchers and practitioners can use to evaluate model clone detectors using mutation analysis on the models each detector is geared towards. MuMonDE applies mutation testing in a novel way by randomly mutating model elements within existing projects to emulate various types of clones that can exist within that domain. It consists of 2 main phases. The mutation phase involves determining the mutation targets, selecting the appropriate mutation operations, and injecting mutants. The second phase, evaluation, involves detecting model clones, preprocessing clone reports, analyzing those reports to calculate recall and precision, and visualizing the data. We introduce MuMonDE by describing each phase in detail. We present our experiences and examples in successfully developing a MuMonDE implementation capable of evaluating Simulink model clone detectors. We validate MuMonDE by demonstrating its ability to answer evaluation questions and provide insights based on the data it generates. With this research using mutation analysis, our goal is to improve model clone detection and its analytical capabilities, thus improving model‐driven engineering as a whole.

Software engineering is becoming increasingly model-centric. Engineers are using models more within projects and their models are growing in complexity. A challenge facing the modeling community is evaluation of these models. One technique for software evaluation is detecting instances of established "good" or "bad" solutions in a system, often termed design patterns or antipatterns, respectively. Most approaches require implemented code for detection. However, this precludes early-stage analysis, and the evaluation of purely or mostly model-centric systems. In this position paper, we introduce a detection technique that uses answer set programming to find occurrences of patterns within sets of structural and behavioral models. We represent the patterns as rules and the structural and behavioral system models as facts, requiring both model types since some patterns specify both. We provide an overview of our proposed approach, contrast existing work, and present discussion points on its impact on model evaluation and anticipated challenges.

As software architecture methods and tools become increasingly model-driven, evaluating architecture artifacts must adjust correspondingly. Model-driven evaluation of architecture quality has advantages over traditional evaluation techniques, especially when applied in a model-driven context. One approach we found successful in performing model-driven analysis involves using model clone detection, whereby we detect subsystems that are similar to example systems that are positive and negative quality indicators. In this paper we present our ideas on applying model clone detection to realize model-driven evaluation of software architectures, which contain many high-level systems and interactions. We propose having model-based representations of architectural patterns and styles, and employing model clone detection to identify positive and negative architectural aspects for evaluation, including reliability and security. We provide our insights on how this research can be applied to popular architectural paradigms, relation to previous work, and present discussion points on how it will impact software architecture quality evaluation.

Program slicing has long been used to facilitate program understanding. Several approaches have been suggested for computing slices based on different perspectives, including forward slicing, backward slicing, static slicing, and dynamic slicing. The applications of slicing are numerous, including testing, effort estimation, and impact analysis. Surprisingly, given the maturity of slicing, few approaches exist for visualizing slices. In this paper, we present our tool for visualizing large systems based on program slicing and through two visualization idioms: treemaps and bipartite graphs. In particular, we use treemaps to facilitate slicing-based navigation, and we use bipartite graphs to facilitate visual impact analysis by displaying relationships among system decomposition slices showing the relevant computations involving a given slicing variable. We believe our tool will support various software maintenance tasks, including providing analysts an interactive visualization of the impact of potential changes, thus allowing them to plan maintenance accordingly. Finally, we show that, through the use of both existing scalable slicing and scalable visualization approaches, our tool can facilitate analysis of large software systems.

A hurdle in the growth of model driven software engineering is our ability to evaluate the quality of models automatically. One perspective is that software quality is a function of the existence, or lack thereof, of good and bad properties, also known as patterns and antipatterns, respectively. In this paper, we introduce the notion of using model clone detection to detect model pattern and antipattern instances by looking for models that are cross clones of pattern models. By detecting patterns at the model level, analysis is accomplished earlier in the engineering process, can be applied to primarily model-based projects, and remains at the same level of abstraction that engineers are used to. We outline the process of using model clone detection for this purpose, including representing the patterns and detection of instances. We present some Simulink examples of pattern representations and discuss future work and research in the area.

One challenge facing the Model-Driven Engineering community is the need for model quality assurance. Specifically, there should be better facilities for analyzing models automatically. One measure of quality is the presence or absence of good and bad properties, such as patterns and antipatterns, respectively. We elaborate on and validate our earlier idea of detecting patterns in model-based systems using model clone detection by devising a Simulink antipattern instance detector. We chose Simulink because it is prevalent in industry, has mature model clone detection techniques, and interests our industrial partners. We demonstrate our technique using near-miss cross-clone detection to find instances of Simulink antipatterns derived from the literature in four sets of public Simulink projects. We present our detection results, highlight interesting examples, and discuss potential improvements to our approach. We hope this work provides a first step in helping practitioners improve Simulink model quality and further research in the area.

This paper presents a semi-automated framework for identifying and representing different kinds of variability in Simulink models. Based on the observed variants found in similar subsystem patterns inferred using Simone, a text-based model clone detection tool, we propose a set of variability operators for Simulink models. By applying these operators to six example systems, we are able to represent the variability in their similar subsystem patterns as a single subsystem template directly in the Simulink environment. The product of our framework is a single consolidated subsystem model capable of expressing the observed variability across all instances of each inferred pattern. The process of pattern inference and variability analysis is largely automated and can be easily applied to other collections of Simulink models. The framework is aimed at providing assistance to engineers to identify, understand, and visualize patterns of subsystems in a large model set. This understanding may help in reducing maintenance effort and bug identification at an early stage of the software development.

Model Clone Detection is a growing area within the field of software model maintenance. New model clone detection techniques and tools for different types of models are being created, however, there is no clear way of objectively and quantitatively evaluating and comparing them. In this paper, we provide a synopsis of our work in devising and validating an evaluation framework that uses Mutation Analysis to provide such a facility. In order to demonstrate the framework's feasibility and also walk through its steps, we implement a framework implementation for evaluating Simulink model clone detectors. This includes a taxonomy of Simulink mutations, Simulink clone report transformations, and more. We outline how the framework calculates precision and recall, and do so on multiple Simulink model clone detectors. In addition, we also discuss areas of future work, including semantic clone mutations, and developing framework implementations for other model types, like UML. Lastly, we address some lessons we learned during the Ph.D. Process, such as partitioning the work into logical, self-contained, milestones, and being open and willing to engage in other research. We hope that our framework will help cultivate further research gains in Model Clone Detection.

Model-clone detection is a relatively new area and there are a number of different approaches in the literature. As the area continues to mature, it becomes necessary to evaluate and compare these approaches and validate new ones that are introduced. We present a mutation-analysis based model-clone detection framework that attempts to automate and standardize the process of comparing multiple Simulink model-clone detection tools or variations of the same tool. By having such a framework, new research directions in the area of model-clone detection can be facilitated as the framework can be used to validate new techniques as they arise. We begin by presenting challenges unique to model-clone tool comparison including recall calculation, the nature of the clones, and the clone report representation. We propose our framework, which we believe addresses these challenges. This is followed by a presentation of the mutation operators that we plan to inject into our Simulink models that will introduce variations of all the different model clone types that can then be searched for by each respective model-clone detector.

This survey paper presents the current state of model comparison as it applies to Model-Driven Engineering. We look specifically at how model matching is accomplished, the application of the approaches, and the types of models that approaches are intended to work with. Our paper also indicates future trends and directions. We find that many of the latest model comparison techniques are geared towards facilitating arbitrary meta models and use similarity-based matching. Thus far, model versioning is the most prevalent application of model comparison. Recently, however, work on comparison for versioning has begun to stagnate, giving way to other applications. Lastly, there is wide variance among the tools in the amount of user effort required to perform model comparison, as some require more effort to facilitate more generality and expressive power. 1

In this paper, we discuss model-to-model comparison techniques that can be used to assist with model-tomodel transformation testing. Using an existing real-world model transformation, we illustrate and qualitatively evaluate the comparison techniques, highlighting the associated strengths and weaknesses of each in the context of transformation testing. 1

While graph-based techniques show good results in finding exactly similar subgraphs in graphical models, they have great difficulty in finding near-miss matches. Text-based clone detectors, on the other hand, do very well with near-miss matching in source code. In this paper we introduce SIMONE, an adaptation of the mature text-based code clone detector NICAD to the efficient identification of structurally meaningful near-miss subsystem clones in graphical models. By transforming graph-based models to normalized text form, SIMONE extends NICAD to identify near-miss subsystem clones in Simulink models, uncovering important model similarities that are difficult to find in any other way.

Framework-specific modeling languages (FSMLs) help developers build applications based on object-oriented frameworks. FSMLs model abstractions and rules of application programming interfaces (APIs) exposed by frameworks and can express models of how applications use APIs. Such models aid developers in understanding, creating, and evolving application code. We present four exemplar FSMLs and a method for engineering new FSMLs. The method was created postmortem by generalizing the experience of building the exemplars and by specializing existing approaches to domain analysis, software development, and quality evaluation of models and languages. The method is driven by the use cases that the FSML under development should support and the evaluation of the constructed FSML is guided by two existing quality frameworks. The method description provides concrete examples for the engineering steps, outcomes, and challenges. It also provides strategies for making engineering decisions. Our work offers a concrete example of software language engineering and its benefits. FSMLs capture existing domain knowledge in language form and support application code understanding through reverse engineering, application code creation through forward engineering, and application code evolution through round-trip engineering.