Dorian LEROY
Dorian Leroy is a research engineer at LIHPC and holds a PhD in software engineering. He joined CEA in 2022 and explores topics related to V&V (testing, debugging) as well as language engineering, all in the context of scientific computing and HPC. Recently, he has also been focusing on code modernization and language migration, assisted by LLMs.
SLE '23: 16th ACM SIGPLAN International Conference on Software Language Engineering, 2023
abstract
Abstract
Software languages have pros and cons, and are usually chosen accordingly. In this context, it is common to involve different languages in the development of complex systems, each one specifically tailored for a given concern. However, these languages create de facto silos, and offer little support for interoperability with other languages, be it statically or at runtime. In this paper, we report on our experiment on extracting a relevant behavioral interface from an existing language, and using it to enable interoperability at runtime. In particular, we present a systematic approach to define the behavioral interface and we discuss the expertise required to define it. We illustrate our work on the case study of SciHook, a C++ library enabling the runtime instrumentation of scientific software in Python. We present how the proposed approach, combined with SciHook, enables interoperability between Python and a domain-specific language dedicated to numerical analysis, namely NabLab, and discuss overhead at runtime.
Computing in Science & Engineering ( Volume: 24, Issue: 4, 01 July-Aug. 2022), 2022
abstract
Abstract
Scientific codes are complex software systems. Their engineering involves various stakeholders using various computer languages for defining artifacts at different abstraction levels and for different purposes. In this article, we review the overall processes leading to the development of scientific software, and discuss the role of computer languages in the definition of the different artifacts. We provide guidelines to make informed decisions when the time comes to choose a computer language to develop scientific software.
Computer (Volume: 54, Issue: 12, December 2021), 2021
abstract
Abstract
We investigate the different levels of abstraction, linked to the diverse artifacts of the scientific software development process, that a software language can propose and the validation and verification facilities associated with the corresponding level of abstraction the language can provide to the user.
Proceedings of the 14th ACM SIGPLAN International Conference on Software Language Engineering, p. 2-15, 2021
abstract
Abstract
Runtime monitoring and logging are fundamental techniques for analyzing and supervising the behavior of computer programs. However, supporting these techniques for a given language induces significant development costs that can hold language engineers back from providing adequate logging and monitoring tooling for new domain-specific modeling languages. Moreover, runtime monitoring and logging are generally considered as two different techniques: they are thus implemented separately which makes users prone to overlooking their potentially beneficial mutual interactions. We propose a language-agnostic, unifying framework for runtime monitoring and logging and demonstrate how it can be used to define loggers, runtime monitors and combinations of the two, aka. moniloggers. We provide an implementation of the framework that can be used with Java-based executable languages, and evaluate it on 2 implementations of the NabLab interpreter, leveraging in turn the instrumentation facilities offered by Truffle, and those offered by AspectJ.
Abstract
Dealing with complexity is an important challenge in software and systems engineering. In particular, designing such systems requires expertise in various heterogeneous domains. Model-Driven Engineering (MDE) is a development paradigm to cope with this complexity through the conception and use of Domain Specific Languages (DSLs). A DSL captures all the concepts required to solve a set of problems belonging to a particular domain. DSLs are geared toward domain experts without requiring experience with programming languages. Using DSLs, domain experts are able to model parts of a system using only concepts of their domain of expertise. A particular category of DSLs, Executable DSLs (xDSLs), go further as they enable, through a provided execution semantics, the definition of dynamic models, which in turn enables early dynamic Verification and Validation (V&V) activities on these models. All xDSLs share a common need for an ecosystem of tools to create, manipulate, and analyze models. But xDSLs come in many shapes and forms, as each is tailored to aparticular domain, both syntactically and semantically. Thus, for each new xDSL, tools must be developed anew, or existing tools adapted. This is a tedious and error-prone task that prompted advances in the field, enabling core and advanced V&V activities for xDSLs in a unifying way through well-defined metaprogramming approaches and generic tools leveraging them. Yet, important aspects of xDSLs and V&V activities stand to benefit from dedicated metaprogramming approaches and generic tooling, respectively. On one hand, no metaprogramming approach currently allows to define the interactions between the models conforming to an xDSL and their environment. On another hand, features at the heart of important V&V activities such as testing and debugging remain challenging to offer in a generic way. In this thesis, we provide solutions to this problem for a set of tools dedicated to offline and online analysis for xDSLs. This comes under the form of three distinct contributions. First, we provide a new metaprogramming approach to extend the definition of xDSLs to incorporate a clear definition of the possible interactions between conforming models and their environment. Second, we leverage the extended foundations for the definition of xDSLs offered by our metaprogramming approach to provide generic support for offline and online analysis for a broader scope of xDSLs, under the form of trace comprehension operators and runtime monitoring, respectively. Finally, we leverage the contributions of this thesis to provide an advanced generic modeling environment. We provide implementation details of the various tools derived from our contributions that constitute this modeling environment and illustrate how they interact with one another in different V&V scenarios. For instance, we show how they can be combined to enable the definition of test scenarios and oracles for models of reactive systems from execution traces collected during an interactive debugging session. In the context of MDE, where the diversity of xDSLs hampers reuse of tools from one language to another, this thesis aims to extend the foundations upon which generic tools can be defined, and to build upon these extended foundations to provide generic support for defining features of V&V activities such as testing and debugging. This results in an advanced and improved framework in term of V&V for xDSLs, compared to the state of the art.
Abstract
Executable domain-specific languages (DSLs) enable the execution of behavioral models. While an execution is mostly driven by the model content (e.g., control structures), many use cases require interacting with the running model, such as simulating scenarios in an automated or interactive way, or coupling the model with other models of the system or environment. The management of these interactions is usually hardcoded into the semantics of the DSL, which prevents its reuse for other DSLs and the provision of generic interaction-centric tools (e.g., event injector). In this paper, we propose a metalanguage for complementing the definition of executable DSLs with explicit behavioral interfaces to enable external tools to interact with executed models in a unified way. We implemented the proposed metalanguage in the GEMOC Studio and show how behavioral interfaces enable the realization of tools that are generic and thus usable for different executable DSLs.
Automated Software Engineering 27(3), 2020
abstract
Abstract
Model transformations play an important role in the evolution of systems in various fields such as healthcare, automotive and aerospace industry. Thus, it is important to check the correctness of model transformation programs. Several approaches have been proposed to generate test cases for model transformations based on different coverage criteria (e.g., statements, rules, metamodel elements, etc.). However, the execution of a large number of test cases during the evolution of transformation programs is time-consuming and may include a lot of overlap between the test cases. In this paper, we propose a test case selection approach for model transformations based on multi-objective search. We use the non-dominated sorting genetic algorithm (NSGA-II) to find the best trade-offs between two conflicting objectives: (1) maximize the coverage of rules and (2) minimize the execution time of the selected test cases. We validated our approach on several evolution cases of medium and large ATLAS Transformation Language programs.
Abstract
Runtime monitoring is a fundamental technique used throughout the lifecycle of a system for many purposes, such as debugging, testing, or live analytics. While runtime monitoring for general purpose programming languages has seen a great amount of research, developing such complex facilities for any executable Domain Specific Language (DSL) remains a challenging, reoccurring and error prone task. A generic solution must both support a wide range of executable DSLs (xDSLs) and induce as little execution time overhead as possible. Our contribution is a fully generic approach based on a temporal property language with a semantics tailored for runtime verification. Properties can be compiled to efficient runtime monitors that can be attached to any kind of executable discrete event model within an integrated development environment. Efficiency is bolstered using a novel combination of structural model queries and complex event processing. Our evaluation on 3 xDSLs shows that the approach is applicable with an execution time overhead of 121% (on executions shorter than 1s), to 79% (on executions shorter than 20s) making it suitable for model testing and debugging.
14th European Conference on Modelling Foundations and Applications, 2018
abstract
Abstract
Recent approaches contribute facilities to breathe life into metamodels, thus making behavioral models directly executable. Such facilities are particularly helpful to better utilize a model over the time dimension, e.g., for early validation and verification. However, when even a small change is made to the model, to the language definition (e.g., semantic variation points), or to the external stimuli of an execution scenario, it remains difficult for a designer to grasp the impact of such a change on the resulting execution trace. This prevents accessible trade-off analysis and design-space exploration on behavioral models. In this paper, we propose a set of formally defined operators for analyzing execution traces. The operators include dynamic trace filtering, trace comparison with diff computation and visualization, and graph-based view extraction to analyze cycles. The operators are applied and validated on a demonstrative example that highlight their usefulness for the comprehension specific aspects of the underlying traces.
Journal of Systems and Software Volume 137, March 2018, Pages 261-288, 2017
abstract
Abstract
Omniscient debugging is a promising technique that relies on execution traces to enable free traversal of the states reached by a model (or program) during an execution. While a few General-Purpose Languages (GPLs) already have support for omniscient debugging, developing such a complex tool for any executable Domain Specific Language (DSL) remains a challenging and error prone task. A generic solution must: support a wide range of executable DSLs independently of the metaprogramming approaches used for implementing their semantics; be efficient for good responsiveness. Our contribution relies on a generic omniscient debugger supported by efficient generic trace management facilities. To support a wide range of executable DSLs, the debugger provides a common set of debugging facilities, and is based on a pattern to define runtime services independently of metaprogramming approaches. Results show that our debugger can be used with various executable DSLs implemented with different metaprogramming approaches. As compared to a solution that copies the model at each step, it is on average sixtimes more efficient in memory, and at least 2.2 faster when exploring past execution states, while only slowing down the execution 1.6 times on average.