Model-Driven Engineering tools require model instances for testing, validation, and demonstration purposes, yet manually creating such instances is tedious and error-prone. This paper presents the EMF Model Generator, a lightweight Java library for programmatically generating valid model instances from Eclipse Modeling Framework (EMF) metamodels. The tool uses a deterministic, configurable approach based on specialized setter components for attributes, containment references, cross-references, and feature maps, producing reproducible results. It handles complex EMF semantics including bidirectional references, multiplicity constraints, abstract classes with polymorphic instantiation, recursive containment structures, and heterogeneous feature maps. The architecture provides multiple customization levels, from high-level configuration to per-feature functions and complete setter replacement. The tool integrates directly with EMF’s reflective API without external dependencies, making it suitable for testing, prototyping, and demonstration purposes where predictable, valid model instances are needed.

Abstract The study addresses a recurring practical problem: how to obtain high confidence in the correctness of an Eclipse/Xtext-based DSL toolchain—spanning language services, IDE integration, and UI workflows—while keeping builds and releases reproducible and CI-friendly across platforms. We present a general, practice-oriented testing and CI framework for such toolchains and instantiate it in Edelta, an open-source framework and Xtext-based DSL for the evolution and refactoring of EMF metamodels and models. We describe a comprehensive testing strategy, based on test-driven development, spanning fast unit tests for the runtime and refactoring libraries, headless DSL tests for parsing, scoping, validation, type checking, interpretation, and code generation, IDE integration tests for the Eclipse editor, and end-to-end SWTBot tests that exercise complete user workflows. These tests are orchestrated in a single Maven/Tycho build and continuously executed on GitHub Actions across platforms, with SonarCloud providing code-quality and coverage feedback. Our CI setup also builds and verifies distributable Eclipse products and a self-contained p2 update site. An empirical analysis of a representative CI run shows a clear testing-pyramid distribution, with most checks implemented at the fastest layers, keeping the overall CI turnaround time low while providing high confidence in correctness. We summarize lessons learned, actionable guidelines, and pitfalls to avoid when engineering Eclipse- and Xtext-based research software that must be both feature-rich and continuously releasable.

In Model-Driven Engineering, metamodels define the vocabulary of concepts and relations that designers use to define a wide range of artifacts, including models, transformations, and editors. Therefore, whenever a metamodel undergoes modifications, the depending artifacts may no longer be valid, and consistency needs to be repaired through coupled evolution techniques. While several approaches have been proposed over the last decades, they are artifact- and domain-specific and do not facilitate the reuse of migration strategies. Indeed, migration strategies are often hard-coded for a given project in a specific domain. In this paper, we propose the novel concept of migration patterns to leverage reuse across different domains and projects. The approach extends the existing Edelta framework and has been evaluated by considering several case studies identified in a systematic literature review.

Java reflection allows a program to inspect the structure of objects at run-time and provides a powerful mechanism to achieve many interesting dynamic features in several Java frameworks. However, reflection breaks the static type safety properties of Java programs and introduces a run-time overhead; thus, it might be better to avoid reflection when possible. In this paper, we present a novel Java testing framework where reflection is never used: we implement the framework only with the Object-Oriented and functional programming mechanisms provided by Java. We will show that implementing and using such a framework is easy, and we avoid the run-time overhead of reflection. Our framework can be used with existing testing libraries and is meant to be extendable.

Abstract Software development for robotics applications is still a major challenge that becomes even more complex when considering multi-robot systems (MRSs). Such distributed software has to perform multiple cooperating tasks in a well-coordinated manner to avoid unsatisfactory emerging behavior. This paper provides an approach for programming MRSs at a high abstraction level using the programming language X-Klaim. The computation and communication model of X-Klaim, based on multiple distributed tuple spaces, permits coordinating with the same abstractions and mechanisms both intra- and inter-robot interactions of an MRS. This allows developers to focus on MRS behavior, achieving readable, reusable, and maintainable code. The proposed approach can be used in practice by integrating X-Klaim and the popular robotics framework ROS. We demonstrate the feasibility and effectiveness of our approach by (i) showing how it scales when implementing two warehouse scenarios allowing us to reuse most of the code when passing from the simpler to the more enriched scenario and (ii) presenting the results of a few experiments showing that our code introduces a slightly greater but acceptable latency and consumes less memory than the traditional ROS implementation based on Python code.

Abstract Like any software artifacts, metamodels are evolving entities that constantly change over time for different reasons. Changing metamodels by keeping them consistent with other existing artifacts is an error-prone and tedious activity without the availability of automated support. In this paper, we foster the adoption of metamodel refactorings collected in a curated catalog. The Edelta framework is proposed as an operative environment to provide modelers with constructs for specifying basic refactorings and evolution operators, to define a complete metamodel refactoring catalog. The proposed environment has been used to implement the metamodel refactorings available in the literature and make them executable. A detailed discussion on how modelers can use and contribute to the definition of the catalog is also given.

Abstract Metamodels play a crucial role in any model-based application. They underpin the definition of models and tools, and the development of model management operations, including model transformations and analysis. Like any software artifacts, metamodels are subject to evolution to improve their quality or implement unforeseen requirements. Metamodels can be defined in terms of existing ones to increase the separation of concerns and foster reuse. However, the induced coupling can give additional evolution complexity, and dedicated support is needed to avoid breaking metamodels defined in terms of those being changed. This paper presents a tool-supported approach that can automatically analyze the available metamodels and alert modelers in case of change operations that can give place to invalid situations like dangling references. The approach has been implemented in the Edelta development environment and successfully applied to metamodels retrieved from a publicly available Ecore models dataset.

We present FJ&$\lambda$, a new core calculus that extends Featherweight Java (FJ) with interfaces, supporting multiple inheritance in a restricted form, $\lambda$-expressions, and intersection types. Our main goal is to formalise how lambdas and intersection types are grafted on Java 8, by studying their properties in a formal setting. We show how intersection types play a significant role in several cases, in particular in the typecast of a $\lambda$-expression and in the typing of conditional expressions. We also embody interface \emph{default methods} in FJ&$\lambda$, since they increase the dynamism of $\lambda$-expressions, by allowing these methods to be called on $\lambda$-expressions. The crucial point in Java 8 and in our calculus is that $\lambda$-expressions can have various types according to the context requirements (target types): indeed, Java code does not compile when $\lambda$-expressions come without target types. In particular, in the operational semantics we must record target types by decorating $\lambda$-expressions, otherwise they would be lost in the runtime expressions. We prove the subject reduction property and progress for the resulting calculus, and we give a type inference algorithm that returns the type of a given program if it is well typed. The design of FJ&$\lambda$ has been driven by the aim of making it a subset of Java 8, while preserving the elegance and compactness of FJ. Indeed, FJ&$\lambda$ programs are typed and behave the same as Java programs.

The Eclipse Modeling Framework (EMF) is the official Eclipse modeling framework. It provides code generation facilities for building tools and applications based on structured data models. The Eclipse project EMF Parsley enhances the EMF reflective mechanisms in order to make the development of EMF applications easier by hiding most EMF internal details and by using dependency injection for customizing all the aspects of such applications. In this paper we show the main features of the EMF Parsley DSL that aims at making the development of EMF applications even easier and faster. The DSL is built with Xtext and Xbase, thus it features full Eclipse IDE support and full interoperability with Java.

The artifact evaluation committee (AEC) is in charge of evaluating data and software that accompany papers accepted at the ESEC/FSE'13 research track. Authors of more than 40% of the accepted papers have submitted an artifact (22 out of the 51 accepted papers). The AEC has positively evaluated more than 50% of the submitted artifacts. 12 out of the 22 artifacts have been graded as ``met expectations'' or ``exceeded expectations''.

Guaranteeing that the parties of a network application respect a given protocol is a crucial issue.Session typesoffer a method for abstracting and validating structured communication sequences (sessions).Object-oriented programmingis an established paradigm for large scale applications.Union types, which behave as the least common supertypes of a set of classes, allow the implementation of unrelated classes with similar interfaces without additional programming. We have previously developed an integration of the features above into a class-based core language for building network applications, and this successfully amalgamated sessions and methods so that data can be exchanged flexibly according to communication protocols (session types). The first aim of the work reported in this paper is to provide a full proof of the type safety property for that core language by renewing syntax, typing and semantics. In this way, static typechecking guarantees that after a session has started, computation cannot get stuck on a communication deadlock. The second aim is to define a constraint-based type system that reconstructs the appropriate session types of session declarations instead of assuming that session types are explicitly given by the programmer. Such an algorithm can save programming work, and automatically presents an abstract view of the communications of the sessions.

Generic programming is a mechanism for re-using code by abstracting specific types used in classes and programs. In this paper, we present a mechanism for adding generic programming in dynamically typed languages, showing how programmers can benefit from generic programming. Furthermore, we enhance the expressiveness of generic programming with reverse generics, a mechanism for automatically deriving new generic code starting from existing non-generic one. We implemented generics and reverse generics in Pharo Smalltalk, and we successfully used them to solve a problem of reusing unit test cases. This helped us to identify a number of bugs and anomalies in the stream class hierarchy.

Dynamic trait replacement is a programming language feature for changing the objects' behavior at runtime by replacing some of the objects' methods. In previous work on dynamic trait replacement for JAVA-like languages, the object's methods that may be replaced must correspond exactly to a named trait used in the object's class definition. In this paper we propose the notion of replaceable: a programming language feature that decouples trait replacement operation code and class declaration code, thus making it possible refactoring classes and/or performing unanticipated trait replacement operations without invalidating existing code.

Double dispatch is the ability to dynamically select a method not only according to the run-time type of the receiver (single dispatch), but also according to the run-time type of the argument. This mechanism unleashes the power of dynamic binding in object-oriented languages, so enhancing re-usability and separation of responsibilities. However, many mainstream languages, such as, e.g., C++ and Java, do not provide it, resorting only to single dispatch. In this paper we propose an extension of C++ (also applicable to other object-oriented languages) that enables double dispatch as a language feature. This yields dynamic overloading and covariant specialization of methods. We define a translation from the new constructs to standard C++ and we present the preprocessor implementing this translation, called doublecpp. The translated code enjoys static type safety and implements the semantics of double dispatch by using only standard mechanisms of static overloading and dynamic binding, with minimal impact on the performance of the program. Copyright © 2006 John Wiley & Sons, Ltd.

In this paper we propose a new environment for allowing students of a first programming undergraduate course to test their Java code. This environment allows the student to learn the basics of the Java language without necessarily knowing the object-oriented features of the language itself, and the teacher to propose new tests by making use of a graphical test editor. Moreover, the client-server architecture of the Web-based version of the environment is designed so that the student does not even need a Java virtual machine on its computing device, but only a Web browser. This latter feature makes our environment a useful tool for ubiquitous testing of Java programming skills.

Abstract Highly distributed networks have now become a common infrastructure for wide‐area distributed applications whose key design principle is network awareness, namely the ability to deal with dynamic changes of the network environment. Network‐aware computing has called for new programming languages that exploit the mobility paradigm as a basic interaction mechanism. In this paper we present the architecture of KLAVA, an experimental Java package for distributed applications and code mobility. We describe how KLAVA permits code mobility by relying on Java and present a few distributed applications that exploit mobile code programmed in KLAVA. Copyright © 2002 John Wiley & Sons, Ltd.