Publications

Software development increasingly involves heterogeneous stakeholders, including diverse human contributors and AI-powered agents. This amplifies governance challenges around transparency, participation, and accountability, particularly in Open-Source Software (OSS) projects where policies are usually implicit. Building on our prior vision paper, we present a framework for defining and enforcing governance policies via a Domain-Specific Language (DSL) and an executable decision engine. The DSL captures scopes, roles and individuals (with weighted participation and profiles), policy composition and deadlines, and platform-aware conditions. The engine operationalizes policies over collaboration events and records votes, rationales, and timestamps for traceability. We extend the core language with bindings for GitHub and GitLab and provide a form-based editor to ease authoring. We evaluate expressivity by formalizing existing GOVERNANCE.md files from a curated dataset and demonstrate enactment by reproducing three governance policies from different GitHub repositories.

The stakeholders involved in software development are becoming increasingly diverse, with both human contributors from varied backgrounds and AI-powered agents collaborating together in the process. This situation presents unique governance challenges, particularly in Open-Source Software (OSS) projects, where explicit policies are often lacking or unclear. This paper presents the vision and foundational concepts for a novel Domain-Specific Language (DSL) designed to define and enforce rich governance policies in systems involving diverse stakeholders, including agents. This DSL offers a pathway towards more robust, adaptable, and ultimately automated governance, paving the way for more effective collaboration in software projects, especially OSS ones.

The growth of machine learning (ML) models and associated datasets triggers a consequent dramatic increase in energy costs for the use and training of these models. In the current context of environmental awareness and global sustainability concerns involving ICT, Green AI is becoming an important research topic. Initiatives like the AI Energy Score Ratings are a good example. Nevertheless, these benchmarking attempts are still to be integrated with existing work on Quality Models and Service-Level Agreements common in other, more mature, ICT subfields. This limits the (automatic) analysis of this model energy descriptions and their use in (semi)automatic model comparison, selection, and certification processes. We aim to leverage the concept of quality models and merge it with existing ML model reporting initiatives and Green/Frugal AI proposals to formalize a Sustainable Quality Model for AI/ML models. As a first step, we propose a new Domain-Specific Language to precisely define the sustainability aspects of an ML model (including the energy costs for its different tasks). This information can then be exported as an extended version of the well-known Model Cards initiative while, at the same time, being formal enough to be input of any other model description automatic process.

Nowadays, software is everywhere, from computers to smart home appliance. The behavioral aspect of those systems is realized through complex pieces of software. This software complexity can be classified in two types: Essential where the complexity is inherent to the problem and Accidental where it results from the use of inappropriate tools. Model-Driven Engineering (MDE) is a field of software engineering tackling software complexity using models to manage essential complexity and reduce accidental complexity. One part of MDE consist in developing software languages to define those models with an appropriate level of abstraction for the domain. These languages are known as Domain-Specific Languages (DSLs). Software Language Engineering (SLE) is a field of software engineering emerging from the concerns related to DSLs development. Following the claim that “Software languages are software too”, the SLE community focuses on providing tools and methods to facilitate the development of the type of software that are DSLs. The context of this thesis is at the crossroad of these two fields.
Software systems are now evolving in complex and changing environments, requiring dynamic self-adaptation to best deliver the services. The self-adaptive systems community provided through time multiple architectural patterns and frameworks to tackle this concern. However, when self-adaptation is a secondary concern, and therefore not in the area of expertise of domain experts, architectural patterns generally do not provide support and frameworks are restricted to languages for which they were designed. In the context of DSLs, the re-implementation of these frameworks would be prohibitively complex. From this observation we derive the following research question “How to abstract the self-adaptation concern for DSL users when it is a secondary but important concern?”.
To address this problem, we propose the concept of Self-Adaptable Languages (SALs). SALs abstract self-adaptation into high-level language constructs similarly to memory management in Java. In this thesis we focus on the Self-Adaptable Operational Semantics. Based on our research question, we draw two challenges for Self-Adaptable Operational Semantics: (1) “How to specify and derive implementation of self-adaptable operational semantics to enable reasoning and check properties, without impactful performances overhead of the language runtime?” and (2) “What are the relevant abstractions to implement self-adaptable operational semantics?”.
We address the first challenge through our first contribution: Adaptive Structural Operational Semantics (ASOS). ASOS is a metalanguage designed to specify and reason about self-adaptable operational semantics. On top of this metalanguage we provide both a formal semantics for reasoning and a translational semantics generating an implementation of the specified semantics. The second challenge is addressed by the SElf-Adaptable LanguageS (SEALS) framework, our second contribution. SEALS is a Java framework providing abstraction to both support the language engineer in the development of the language abstract syntax and operational semantics and the design of the feedback loop and adaptations.
We evaluate, among other, the applicability of the approach and the performance of the resulting implementation on three languages: RobLANG, HTML, and MiniJava. For both contributions, we demonstrate the ability to perform relevant adaptations for the domain at the language level without performance pitfalls.

The notion of polyglot software development refers to the fact that most software projects nowadays rely on multiple languages to deal with widely different concerns, from core business concerns to user interface, security, and deployment concerns among many others. Many different wordings around this notion have been proposed in the literature, with little understanding of their differences. In this article, we propose a concise and unambiguous definition of polyglot software development including a conceptual model and its illustration on a well-known, open-source project. We further characterize the techniques used for the specification and operationalization of polyglot software development with a feature model, concentrating on polyglot programming. We conclude the article outlining the many challenges and perspectives raised by polyglot software development.

Software systems evolve more and more in complex and changing environments, often requiring runtime adaptation to best deliver their services. When self-adaptation is the main concern of the system, a manual implementation of the underlying feedback loop and trade-off analysis may be desirable. However, the required expertise and substantial development effort make such implementations prohibitively difficult when it is only a secondary concern for the given domain. In this paper, we present ASOS, a metalanguage abstracting the runtime adaptation concern of a given domain in the behavioral semantics of a domain-specific language (DSL), freeing the language user from implementing it from scratch for each system in the domain. We demonstrate our approach on RobLANG, a procedural DSL for robotics, where we abstract a recurrent energy-saving behavior depending on the context. We provide formal semantics for ASOS and pave the way for checking properties such as determinism, completeness, and termination of the resulting self-adaptable language. We provide first results on the performance of our approach compared to a manual implementation of this self-adaptable behavior. We demonstrate, for RobLANG, that our approach provides suitable abstractions for specifying sound adaptive operational semantics while being more efficient.

Over recent years, self-adaptation has become a major concern for software systems that evolve in changing environments. While expert developers may choose a manual implementation when self-adaptation is the primary concern, self-adaptation should be abstracted for non-expert developers or when it is a secondary concern. We present SEALS, a framework for building self-adaptive virtual machines for domain specific languages. This framework provides first-class entities for the language engineer to promote domain-specific feedback loops in the definition of the DSL operational semantics. In particular, the framework supports the definition of (i) the abstract syntax and the semantics of the language as well as the correctness envelope defining the acceptable semantics for a domain concept, (ii) the feedback loop and associated trade-off reasoning, and (iii) the adaptations and the predictive model of their impact on the trade-off. We use this framework to build three languages with self-adaptive virtual machines and discuss the relevance of the abstractions, effectiveness of correctness envelopes, and compare their code size and performance results to their manually implemented counterparts. We show that the framework provides suitable abstractions for the implementation of self-adaptive operational semantics while introducing little performance overhead compared to a manual implementation.

Over recent years, self-adaptation has become a concern for many software systems that have to operate in complex and changing environments. At the core of self-adaptation, there is a feedback loop and associated trade-off reasoning to decide on the best course of action. However, existing software languages do not abstract the development and execution of such feedback loops for self-adaptable systems. Developers have to fall back to ad-hoc solutions to implement self-adaptable systems, often with wide-ranging design implications (e.g., explicit MAPE-K loop). Furthermore, existing software languages do not capitalize on monitored usage data of a language and its modeling environment. This hinders the continuous and automatic evolution of a software language based on feedback loops from the modeling environment and runtime software system. To address the aforementioned issues, this paper introduces the concept of Self-Adaptable Language (SAL) to abstract the feedback loops at both system and language levels. We propose L-MODA (Language, Models, and Data) as a conceptual reference framework that characterizes the possible feedback loops abstracted into a SAL. To demonstrate SALs, we present emerging results on the abstraction of the system feedback loop into the language semantics. We report on the concept of Self-Adaptable Virtual Machines as an example of semantic adaptation in a language interpreter and present a roadmap for SALs.

Numerous language workbenches have been proposed over the past decade to ease the definition of Domain-Specific Languages (DSLs).Language workbenches enable DSL designers to specify DSLs using high-level metalanguages, and to automatically generate their implementation (e.g., parsers, interpreters) and tool support (e.g., editors, debuggers). However, little attention has been given to the performance of the resulting interpreters. In many domains where performance is key (e.g., scientific and high-performance computing), this forces DSL designers to handcraft ad-hoc optimizations in interpreter implementations, or lose compatibility with tool support. In this paper, we propose to systematically exploit domain-specific information of DSL specifications to derive optimized Truffle-based language interpreters executed over the GraalVM. Those optimizations are provided at no extra cost for the DSL designer. They are of course not as efficient as handcrafted optimizations, but do not require extra time or knowledge from the DSL designer (which industrial DSL designers often lack). We implement our approach on top of the Eclipse Modeling Framework (EMF) by complementing its existing compilation chain with Truffle-specific information, which drives GraalVM to benefit from optimized just-in-time compilation. A key benefit of our approach is that it leverages existing DSL specifications and does not require additional information from DSL designers who remain oblivious of Truffle’s low-level intricacies and JIT optimizations in general while staying compatible with tool support. We evaluate our approach using a representative set of four DSLs and eight conforming programs. Compared to the standard interpreters generated by EMF running on GraalVM, we observe an average speed-up of x1.14, ranging from x1.07 to x1.26. Although the benefits vary slightly from one DSL or program to another, we conclude that our approach yields substantial performance gains while remaining non-intrusive of EMF abstractions.