Using package managers is a simple and common method for reusing code through project dependencies. However, these, direct, dependencies can themselves rely on additional packages, resulting in indirect dependencies. It may then become complex to get a grasp of the whole set of dependencies of a project. Beyond studying individual projects, a deep understanding of software ecosystems is also a critical prerequisite for achieving sustained success in software development. This paper presents the 2025 edition of the MSR conference mining challenge. This year’s mining challenge focuses on dependencies and dependency ecosystem analysis using the Goblin framework that has been presented at the previous edition of the MSR conference. Goblin is composed of a Neo4j Maven Central dependency graph and a tool called Weaver for on-demand metric weaving into dependency graphs. As a whole, Goblin is a customizable framework for ecosystem and dependency analysis.

Keeping dependencies up to date is a crucial software maintenance task that requires significant effort. Developers must choose which dependencies to update, select appropriate target versions, and minimize the impact of updates in terms of breaking changes and incompatibilities. Several factors influence the choice of a new dependency version, including its freshness, popularity, absence of vulnerabilities, and compatibility.

Dependency graphs support software maintenance and software ecosystem analysis. Several metrics can be used on top of these graph models but the set of such metrics is to evolve over time. Further, some metrics have a dynamic nature, requiring being able to "rewind" dependency graphs at some point in time. To address these issues we propose the Goblin framework. It is composed of a dependency graph metamodel with time-related information, a miner to retrieve the graph from Maven Central, and a tool for on-demand metric weaving into dependency graphs. As a whole, Goblin is a customizable framework for ecosystem and dependency analysis. This is illustrated with a set of complementary experiments. Our tools, datasets, and experiments are freely available online.

International audience

Choreographies are contracts specifying from a global point of view the legal interactions that must take place among a set of services. Such a contract may serve as a reference in the development of concurrent distributed system, whether it is achieved following a top-down or a bottom-up approach. In this article, we present VerChor, a generic, modular, and extensible framework for supporting the development based on choreographies. It relies on a choreography intermediate format (CIF) into which several existing choreography description languages can be transformed. VerChor builds around a set of formal properties whose verification is central to choreography-based development. To support this development process, we propose a connection between CIF and the CADP verification toolbox, which enables the full automation of the aforementioned properties. Finally, we illustrate a practical use of the VerChor framework through its integration with the Eclipse BPMN 2.0 designer.

Service-oriented engineering is an emerging software development paradigm for distributed collaborative applications. Services are developed independently and are composed to achieve common requirements. Service choreographies define such requirements from a global perspective, based on interactions among a set of participants that are implemented as services. In this paper, we support a reliable data-aware service choreography development process through a dedicated projection. It extracts, from a choreography, a behavioral skeleton for each of its participants. The projection is valuable in a top-down approach, where developers have only to complete the skeletons with some business code in order to get a distributed application that matches the choreography requirements. The projection is also valuable in a bottom-up approach, where the skeletons can act as controllers between reused services in order to enforce the respect of the choreography. Our approach is supported with a tool that can be downloaded or used online.

Reuse and composition are increasingly advocated and put into practice in modern software engineering. However, the software entities that are to be reused to build an application, e.g., services, have seldom been developed to integrate and to cope with the application requirements. As a consequence, they present mismatch, which directly hampers their reusability and the possibility of composing them. Software Adaptation has become a hot topic as a nonintrusive solution to work mismatch out using corrective pieces named adaptors. However, adaptation is a complex issue, especially when behavioral interfaces, or conversations, are taken into account. In this paper, we present state-of-the-art techniques to generate adaptors given the description of reused entities' conversations and an abstract specification of the way mismatch can be solved. We use a process algebra to encode the adaptation problem, and propose on-the-fly exploration and reduction techniques to compute adaptor protocols. Our approach follows the model-driven engineering paradigm, applied to service-oriented computing as a representative field of composition-based software engineering. We take service description languages as inputs of the adaptation process and we implement adaptors as centralized service compositions, i.e., orchestrations. Our approach is completely tool supported.

Service composition is nowadays mainly seen as a once-for-all activity. Supporting a dynamic service world, where both available services and needs may change, requires runtime adaptive features for service composition. In this paper we propose a repair technique for internal composition adaptation, as opposed to external adaptation. Moreover, setting up our proposal in the planning framework, we compare our repair technique with reference to re-composition, that is re-planning.

Component-Based Software Engineering focuses on the reuse of existing software components. In practice, most components cannot be integrated directly into an application-to-be, because they are incompatible. Software Adaptation aims at generating, as automatically as possible, adaptors to compensate mismatch between component interfaces, and is therefore a promising solution for the development of a real market of components promoting software reuse. In this article, we present our approach for software adaptation which relies on an abstract notation based on synchronous vectors and transition systems for governing adaptation rules. Our proposal is supported by dedicated algorithms that generate automatically adaptor protocols. These algorithms have been implemented in a tool, called Adaptor, that can be used through a user-friendly graphical interface.

Software adaptation has been proposed as a solution to mismatch between components through the generation of software pieces called adaptors. We propose a new behavioral adaptation approach for the generation of adaptor protocols. Compared to related work, it is fully automated and addresses the adaptor computation complexity thanks to process algebra encodings and on-the-fly techniques.

Separation of concerns or aspects is a way to deal with the increasing complexity of systems. The separate design of models for different aspects also promotes a better reusability level. However, an important issue is then to define means to integrate them into a global model. We present a formal and tool-equipped approach for the integration of dynamic models (behaviors expressed using state diagrams) and static models (formal data types) with the benefit to share advantages of both: graphical user-friendly models for behaviors, formal and abstract models for data types. Integration is achieved in a generic way so that it can deal with both different static specification languages (algebraic specifications, Z, B) and different dynamic specification semantics

Formal specifications are now widely accepted in software development. Recently, the need for a separation of concerns with reference to static and dynamic aspects appeared. Furthermore, in order to be able to design complex architectures and communication patterns, we need a structured approach which allows us to decompose a system into subparts and to recompose it from them. Finally, a notion of formal reusable component which is suitable to describe both functional and dynamic aspects is also required. This paper presents the Korrigan model. It allows one to specify in a uniform and structured way both datatypes and behaviours using Symbolic Transition Systems and algebraic specifications. We demonstrate its ability to describe reusable components in a formal way with well defined interfaces. We also demonstrate that Korrigan is relevant to describe the architecture and communication schemes of systems that may present a complex structure.