International audience

International audience

Git social platforms (such as Gitlab, Github, or Bitbucket) provide insight into a team’s workflow. Mining Software Repositories (MSR) provides methods and tools to extract data from these platforms. However, most tools lack connectivity and extensibility across multiple platforms. Moreover, they rarely connect to other project management platforms such as Jira. In this paper, we introduce GitProjectHealth (GPH), a framework to extract data from any Git repositories and social platforms. GPH is implemented inside a model-driven engineering framework in Pharo smalltalk, facilitating its extension to other social platforms. We demonstrate GPH features over 3 open-source organizations: Eclipse, MooseTechnology and Microsoft; as well as Berger-Levrault, a closed-source company. We extracted their activity to build distributions of commits by user and to determine which types of ticket were associated with each merge request.

Legacy software systems often lack extensive testing, but are assumed to behave correctly after years of bug fixes and stable operation. Migrating or modernizing these systems is challenging because there is little support for preventing regressions. Test carving addresses this problem by generating unit tests based on the current behavior of the system, treating it as an implicit oracle. In this paper, we present Modest,a multi-language tool that generates unit tests by carving them from execution traces. Modestprocesses method calls, including their receivers, arguments, and results, to recreate these invocations as unit tests. Its model-based approach allows it to support multiple languages. We detail how it can be extended to handle additional languages. Modestaims to generate tests that are human-readable and maintainable over time. To achieve this, it reconstructs values as source code rather than relying on deserialization. We evaluate Modestby generating tests for both Java and Pharo applications.

Migrating large monolithic systems to service-based architecture is a complex process, mainly due to the difficulty of extracting reusable functionality from tightly coupled components. To support this, Service Identification techniques have been proposed to decompose monoliths into service candidates. Implementing these service candidates requires significant restructuring efforts. To address this complexity and build confidence in the target architecture, prior research recommends using an incremental migration approach where services are extracted one at a time. However, incremental migration has been poorly explored in the literature and lacks dedicated tool support. Thus, we explore the idea of a tool-assisted service extraction to support incremental migration, where one service is extracted at each increment. This paper first discusses the challenges associated with incremental migration. Then, it presents a model-based extraction approach aimed at automatically extracting functionality as a service. The approach is supported by a tool prototype evaluated on an industrial system and an open-source project. Our results show that our tool can extract standalone services that are successfully invoked by a reduced version of the monolith.

Since their introduction, mobile application development has become complex and now rivals web app development. The primary factor contributing to this complexity is their monolithic architecture: a mobile application is still deployed as a single unit. In contrast, web applications have adopted modular architectures such as Microservice or Micro FrontEnd (MFE). This last approach divides development into teams, each responsible for an MFE corresponding to a specific software feature. Our study examines the adoption of the MFE architecture on native mobile platforms. This paper discusses: i) how MFE can be adapted to current native mobile platforms; ii) the limitations of adapting MFE architecture on mobile; and iii) the challenges MFE introduces to mobile application development. Despite challenges in composing mobile MFEs post-deployment, our research highlighted maintaining a static development-side composite is feasible, albeit with a loss of flexibility. This allows team separation and independent feature development, though technological agnosticism isn't achieved.

International audience

In a collaboration with Berger-Levrault, a major IT company, we are working on the migration of GWT applications to Angular. We focus on the GUI aspect of this migration which requires a framework switch (GWT to Angular) and a programming language switch (Java to TypeScript). Previous work identified that the GUI can be split into the UI structure and the GUI behavioral code. GUI behavioral code is the code executed when the user interacts with the UI. Although the migration of UI structure has already been studied, the migration of the GUI behavioral code has not. To help developers during the migration of their applications, we propose a generic approach in four steps that uses a meta-model to represent the GUI behavioral code. This approach includes a separation of the GUI behavioral code into events (caller code) and the code executed when an event is fired (called code). We present the approach and its implementation for a real industrial case study. The application comprises 470 Java (GWT) classes representing 56 web pages. We give examples of the migrated code. We evaluate the quality of the generated code with standard tools (SonarQube, codelizer) and compare it to another Java to TypeScript converter. The results show that our code has 53% fewer warnings and rule violations for SonarQube, and 99% fewer for codelizer.

A popular recommendation to programmers in object-oriented software is to "program to an interface, not an implementation" (PTI). Expected benefits include increased simplicity from abstraction, decreased dependency on implementations, and higher flexibility. Yet, interfaces must be immutable, excessive class hierarchies can be a form of complexity, and "speculative generality" is a known code smell. To advance the empirical knowledge of PTI, we conducted an empirical investigation that involves 126 Java projects on GitHub, aiming to measuring the decreased dependency benefits (in terms of cochange).

During the evolution of an application, it happens that developers must change the programming language. In the context of a collaboration with Berger-Levrault, a major IT company, we are working on the migration of a GWT application to Angular. We focus on the GUI aspect of this migration which, even if both frameworks are web Graphical User Interface (GUI) frameworks, is made difficult because they use different programming languages and different organization schema. Such migration is complicated by the fact that the new application must be able to mimic closely the visual aspect of the old one so that the users of the application are not disrupted. We propose an approach in four steps that uses a meta-model to represent the GUI at a high abstraction level. We evaluated this approach on an application comprising 470 Java (GWT) classes representing 56 pages. We are able to model all the web pages of the application and 93% of the widgets they contain, and we successfully migrated 26 out of 39 pages (66%). We give examples of the migrated pages, both successful and not.