Class diagrams are widely used in modelling and system design. They capture the relation between the requirements specification (problem domain) and system components (solution domain). However, constant changes to requirements and manual modelling may result in invalid software models, and potentially invalid software solutions. We propose an automated approach at the meta-model level to reason about the validity of diagrams and/or their associated requirements. This paper introduces the foundations of the formal framework TOMM, and illustrates how it can be used for validation of class diagram based models, and potentially extended for model generation and comparison.

Much research was invested in the last decade to develop differencing methods to identify the changes performed between two model versions.Typically, these changes are captured in an explicit difference model.However, quantifying the distance between model versions received less attention.While different versions of a model may have the same amount of changes, their distance to the base model may be drastically different.Therefore, we present distance metrics for models.We provide a method to generate tool support for computing domainspecific distance measures automatically.We show the benefits of distance measures over model differences in the use case of searching for the explanation of model evolution in terms of domain-specific change operations.The results of our experiments show that using distance metrics outperforms the usage of common difference models.

In model-based development projects, models at different abstraction levels capture different aspects of a software system, e.g., specification or design. Inconsistencies between these models can c ...

Comparison of large models can be time-consuming since every element has to be visited, matched, and compared with its respective element in other models. This can result in bottlenecks in collaborative modelling environments, where identifying differences between two versions of a model is desirable. Reducing the comparison process to only the elements that have been modified since a previous known state (e.g., previous version) could significantly reduce the time required for large model comparison. This paper presents how change-based persistence can be used to localise the comparison of models so that only elements affected by recent changes are compared and to substantially reduce comparison and differencing time (up to 90% in some experiments) compared to state-based model comparison.

The verification of complex software systems often requires to check quantitative properties that rely on aggregation operators (e.g., the average response time of a service). One way to ease the specification of these properties is to use property specification patterns, such as the ones for "service provisioning", previously proposed in the literature.

Dynamic Software Update (DSU) solutions update applications while they are executing. These solutions are typically used in production to minimize application downtime, or in integrated development environments to provide live programming support. Each of these scenarios presents different challenges, forcing existing solutions to be designed with only one of these use cases in mind. For example, DSUs for live programming typically do not implement safe point detection or instance migration, while production DSUs require manual generation of patches and lack IDE integration. Also, these solutions have limited ability to update themselves or the language core libraries, and some of them present execution penalties outside the update window. We propose a DSU (gDSU) that works for both live programming and production environments. Our solution implements safe update point detection using call stack manipulation and a reusable instance migration mechanism to minimize manual intervention in patch generation. Moreover, it also offers updates of core language libraries and the update mechanism itself. This is achieved by the incremental copy of the modified objects and an atomic commit operation. We show that our solution does not affect the global performance of the application and it presents only a run-time penalty during the update window. Our solution is able to apply an update impacting 100,000 instances in 1 second. In this 1 second, only during 250 milliseconds the application is not responsive. The rest of the time the application runs normally while gDSU is looking for the safe update point. The update only requires to copy the elements that are modified.

This special issue represents a selection of the best papers of the workshop on Meta-Programming Techniques and Reflection 2016 (Meta'16). Meta'16 was held in Amsterdam, The Netherlands, in October 2016 co-located with SPLASH'16.

We present MTMJ, a multithreaded middleweight model language for Java which is strongly typed and prevents multiple run-time start of threads.The key point in designing the language is to balance precision and efficiency by judicious utilization of context information during type checking.While the types are flow-insensitive, the required flowdependent information is collected as type checking progresses.We prove that our type system is sound and guarantees the good behavior of welltyped programs.In particular, the execution of a typable program does not lead to multiple start of threads.We also develop a type checker as part of this research and apply it to several MTMJ programs.