6.1.1 Heptagon

• Keywords:
  Compilers, Synchronous Language, Controller synthesis
• Functional Description:

  Heptagon is an experimental language for the implementation of embedded real-time reactive systems. It is developed inside the Synchronics large-scale initiative, in collaboration with Inria Rhones-Alpes. It is essentially a subset of Lucid Synchrone, without type inference, type polymorphism and higher-order. It is thus a Lustre-like language extended with hierchical automata in a form very close to SCADE 6. The intention for making this new language and compiler is to develop new aggressive optimization techniques for sequential C code and compilation methods for generating parallel code for different platforms. This explains much of the simplifications we have made in order to ease the development of compilation techniques.

  The current version of the compiler includes the following features: - Inclusion of discrete controller synthesis within the compilation: the language is equipped with a behavioral contract mechanisms, where assumptions can be described, as well as an "enforce" property part. The semantics of this latter is that the property should be enforced by controlling the behaviour of the node equipped with the contract. This property will be enforced by an automatically built controller, which will act on free controllable variables given by the programmer. This extension has been named BZR in previous works. - Expression and compilation of array values with modular memory optimization. The language allows the expression and operations on arrays (access, modification, iterators). With the use of location annotations, the programmer can avoid unnecessary array copies.

• URL:
  https://­gitlab.­inria.­fr/­synchrone/­heptagon
• Contact:
  Gwenaël Delaval
• Participants:
  Adrien Guatto, Brice Gelineau, Cédric Pasteur, Eric Rutten, Gwenaël Delaval, Léonard Gérard, Marc Pouzet
• Partners:
  UGA, ENS Paris, Inria, LIG

6.1.2 SundialsML

• Name:
  Sundials/ML
• Keywords:
  Simulation, Mathematics, Numerical simulations
• Scientific Description:

  Sundials/ML is a comprehensive OCaml interface to the Sundials suite of numerical solvers (CVODE, CVODES, IDA, IDAS, KINSOL). Its structure mostly follows that of the Sundials library, both for ease of reading the existing documentation and for adapting existing source code, but several changes have been made for programming convenience and to increase safety, namely:

  solver sessions are mostly configured via algebraic data types rather than multiple function calls,

  errors are signalled by exceptions not return codes (also from user-supplied callback routines),

  user data is shared between callback routines via closures (partial applications of functions),

  vectors are checked for compatibility (using a combination of static and dynamic checks), and

  explicit free commands are not necessary since OCaml is a garbage-collected language.

• Functional Description:
  Sundials/ML is an OCaml interface to the Sundials suite of numerical solvers (CVODE, CVODES, IDA, IDAS, KINSOL, ARKODE).
• Release Contributions:
  Sundials/ML v6.0.0p0 adds support for v5.x and v6.x of the Sundials Suite of numerical solvers. This includes the latest Arkode features, many vectors, and nonlinear solvers.
• URL:
  http://­inria-parkas.­github.­io/­sundialsml/
• Publications:
  hal-01408230v1, hal-01967659v1
• Contact:
  Timothy Bourke
• Participants:
  Jun Inoue, Marc Pouzet, Timothy Bourke

6.1.3 Zelus

• Keywords:
  Numerical simulations, Compilers, Embedded systems, Hybrid systems
• Scientific Description:
  The Zélus implementation has two main parts: a compiler that transforms Zélus programs into OCaml programs and a runtime library that orchestrates compiled programs and numeric solvers. The runtime can use the Sundials numeric solver, or custom implementations of well-known algorithms for numerically approximating continuous dynamics.
• Functional Description:
  Zélus is a new programming language for hybrid system modeling. It is based on a synchronous language but extends it with Ordinary Differential Equations (ODEs) to model continuous-time behaviors. It allows for combining arbitrarily data-flow equations, hierarchical automata and ODEs. The language keeps all the fundamental features of synchronous languages: the compiler statically ensure the absence of deadlocks and critical races, it is able to generate statically scheduled code running in bounded time and space and a type-system is used to distinguish discrete and logical-time signals from continuous-time ones. The ability to combines those features with ODEs made the language usable both for programming discrete controllers and their physical environment.
• URL:
  https://­zelus.­di.­ens.­fr
• Publications:
  hal-03051954v1, hal-02333603v1, hal-02426533v1, inria-00554271v1, hal-01242732v1, hal-00654113v1, hal-00909029v1, hal-01575621v4, hal-01575631v1, hal-00766726v1, hal-00938891v1, hal-00654112v1, hal-01879026v1, hal-01549183v2, hal-00938866v1
• Contact:
  Marc Pouzet
• Participants:
  Marc Pouzet, Timothy Bourke
• Partner:
  ENS Paris

6.1.4 Vélus

• Name:
  Verified Lustre Compiler
• Keywords:
  Synchronous Language, Compilation, Software Verification, Coq, Ocaml
• Functional Description:
  Vélus is a prototype compiler from a subset of Lustre to assembly code. It is written in a mix of Coq and OCaml and incorporates the CompCert verified C compiler. The compiler includes formal specifications of the semantics and type systems of Lustre, as well as the semantics of intermediate languages, and a proof of correctness that relates the high-level dataflow model to the values produced by iterating the generated assembly code.
• Release Contributions:
  Vélus 3.0 introduces syntax and semantics for Lustre (previous versions only treated the normalized form of Lustre). It includes a verified normalization pass that transforms Lustre programs into NLustre programs.
• URL:
  https://­velus.­inria.­fr
• Publications:
  hal-01817949, hal-03287572, hal-01512286, hal-01403830, tel-03068862, hal-02005639, hal-02426573, hal-03370264
• Contact:
  Timothy Bourke
• Participants:
  Timothy Bourke, Basile Pesin, Paul Jeanmaire, Marc Pouzet

6.1.5 MPPcodegen

• Name:
  Source-to-source loop tiling based on MPP
• Keywords:
  Source-to-source compiler, Polyhedral compilation
• Functional Description:
  MPPcodegen applies a monoparametric tiling to a C program enriched with pragmas specifying the tiling and the scheduling function. The tiling can be generated by any convex polyhedron and translation functions, it is not necessarily a partition. The result is a C program depending on a scaling factor (the parameter). MPPcodegen relies on the MPP mathematical library to tile the iteration sets.
• URL:
  http://­foobar.­ens-lyon.­fr/­mppcodegen/
• Publication:
  hal-02493164
• Authors:
  Christophe Alias, Guillaume Iooss, Sanjay Rajopadhye
• Contact:
  Christophe Alias
• Partner:
  Colorado State University

6.1.6 MPP

• Name:
  MonoParametric Partitionning transformation
• Keywords:
  Compilation, Polyhedral compilation
• Functional Description:
  This library applies a monoparametric partitioning transformation to polyhedra and affine functions. This transformation is a subset of the parametric sized tiling transformation, specialized for the case where shapes depend only on a single parameter. Unlike in the general case, the resulting sets and functions remain in the polyhedral model.
• URL:
  https://­github.­com/­guillaumeiooss/­MPP
• Contact:
  Guillaume Iooss

6.1.7 ProbZelus

• Keywords:
  Probabilistic Programming, Synchronous Language
• Scientific Description:
  ProbZelus is a probabilistic reactive language which provides the facilities of a synchronous language to write control software, with probabilistic constructs to model uncertainties and perform inference-in-the-loop.
• Functional Description:
  ProbZelus is built on top of Zelus a dataflow language à la Scade/Lustre and offers several streaming inference techniques including classic Sequential Monte Carlo (SMC) algorithms and semi-symbolic inference algorithm based on delayed sampling.
• URL:
  https://­github.­com/­IBM/­probzelus
• Authors:
  Guillaume Baudart, Louis Mandel, Eric Atkinson, Benjamin Sherman, Marc Pouzet, Michael Carbin
• Contact:
  Guillaume Baudart
• Partners:
  CSAIL, MIT, IBM

6.1.8 DeepStan

• Keywords:
  Probabilistic Programming, Compilers, Stan, Pyro
• Scientific Description:
  Stan is a probabilistic programming language that is popular in the statistics community, with a high-level syntax for expressing probabilistic models. Stan differs by nature from generative probabilistic programming languages like Pyro. DeepStan is a compiler from Stan to Pyro. Building on Pyro we can extend Stan with support for explicit variational inference guides, automatic guide generation, and deep probabilistic models.
• Functional Description:
  The compiler is a fork of the Stanc3 compiler with two new backends for Pyro and NumPyro. The runtime is packaged as an independent Python library and contains the Stan standard library and thin wrapper for the Pyro/NumPyro runtime.
• URL:
  https://­github.­com/­deepppl
• Contact:
  Guillaume Baudart
• Participants:
  Guillaume Baudart, Louis Mandel
• Partner:
  IBM

Normalizing Lustre:   

We continued the work from last year on translating Lustre programs into the normalized form required by existing compilation passes. Proofs about normalized Lustre programs proceed by induction on a list of equations ordered so that variables are defined before being used. This is not possible in the unrestricted form so we developed a new approach based on induction over an acyclic dependency graph. As part of this work, and to better prepare for future compilation passes, we reimplemented the generation of identifiers and simplified the axioms that specify the underlying OCaml routines that are shared with the CompCert verified C compiler. We wrote and submitted an article on this work to the EMSOFT conference 13. The article was presented at a virtual event in October and received the best paper award.

Adding higher-level constructs:   

Our next major goal in terms of verified Lustre compilation is to specify the semantics of hierarchical state machines and implement verified algorithms to compile them into compositions of simpler constructions. This is the Basile Pesin s thesis topic. Over the last year, we made solid progress toward this goal.

The syntax and semantics of the Vélus compiler was updated with the notion of a “block” to group sets of equations. We added passes to flatten the block structure and proved semantic preservation for these passes. We then generalized the reset operator to blocks. This was surprisingly difficult. It was necessary to adapt the existing treatment for node instances  24, to study existing formalisations and implementations of clock typing, and to treat fby-equations within a block. Next, we augmented blocks with local variable declarations. This involved updating the semantic model, the typing definitions, implementing a compilation pass to rename and lift local variables, and extending the proofs of semantics preservation. During this work we encountered many problems with the “anonymous variables”  25 introduced to treat node subsampling. We thus replaced this mechanism by a simpler solution.

State machines are compiled to switch statements over an enumerated type that encodes possible states  31. We added this construct to the syntax of V?lus and extended the semantic model. The challenge was to adapt the existing relational predicates to define an overall behavior on a set of streams as the conjunction of constraints, one for each branch, over complementary intervals of those streams. It was necessary to impose a global constraint for intervals when the switch statement is inactive (i.e., when the streams it defines must be absent). The resulting model seemed reasonable but we were worried that it would be difficult to treat last variables  31, since they require that branch definitions interact over time. It turns out that this problem can be solved by using a distinct environment and applying last definitions from the top down. The compilation algorithms for the switch and last features have been verified, and the various proofs about typing, clock alignment, and determinism have been restored.

We have defined a subset of state machine features to treat over the next few months and we have made progress on the semantic model.

Abstract Models and Program Verification:   

To date we have focused on proving the correctness of compilation passes. This involves specifying semantic models to define the input/output relation associated with a program, implementing compilation functions to transform the syntax of a program, and proving that the relation is unchanged by the functions. In addition to specifying compiler correctness, semantic models can also serve as a base for verifying individual programs. The challenge is to present and manipulate such detailed specifications in interactive proofs. The potential advantage is to be able to reason on abstract models and to obtain, via the compiler correctness theorem, proofs that apply to generated code. Making this idea work requires solving several scientific and technical challenges. It is the subject of Paul Jeanmaire 's thesis.

We began the year by examining the related literature  39, 28, 26 and performing practical experiments on simple program fragments. We looked at different techniques to improve the readability of program terms in the proof assistant and experimented with dependent types for expressing a programs' type and clock constraints. For programs with subsampling, there are two standard approaches for treating filtered values: add explicit absent markers or reason on unsynchronized streams à la Kahn  35. Our existing semantic models use explicit absent markers but prior work  26 suggests that a Kahn-style model permits simpler and more readable proofs. We thus started to develop a Kahn-style semantics in Coq using C. Paulin-Mohring's library  40. The goal is to reason by rewriting on stream equations in a denotational model and to link this model with the one used in the compiler specifications. We have made solid progress in understanding the library and using it to express and reason about a subset of Lustre operators. Current work is focused on relating this model to the existing one.

Harmonic clocks:   

We studied the extension of a synchronous language with periodic harmonic clocks based on the work of Mandel et al. 29, 41, 30, 37, 38 on n-synchrony and the extension proposed by Forget et al. 34

Mandel et al. considered a language with periodic clocks expressed as ultimately periodic binary sequences. The decision procedures (equality, inclusion, precedence) for such an expressive language can be very costly. It is thus sometimes useful to apply an envelope-based abstraction, that is, one where sets of clocks are represented by a rational slope and an interval. Forget considered simpler “harmonic” clocks. His decision procedures conincide with those for the envelope-based abstraction but without any loss of information. During his M2 internship, B. Pauget continued this line of work by extending the input language of the Vélus Lustre compiler with harmonic clocks. This work was the starting point for the proposal of a new intermediate language for a synchronous compiler that is capable of exploiting clock information to apply agressive optimizations and generate parallel code.

New Intermediate Language MObc (Multi Object Code):   

This intermediate language is reminiscent of the intermediate Obc language used in the Vélus and Heptagon compiler, but with some important differences and new features. MObc permits a synchronous function to be represented as a set of named state variables and possibly nested blocks with a partial ordering which express the way blocks can and must be called. In comparison, Obc represents a synchronous function as a set of state variables and a transition function that is itself written in a sequential language. Each block comprises a set of equations in Single Static Assignment (SSA) form, that is, exactly one equation per variable, so as to simplify the implementation of a number of classic optimizations (for example, constant propagation, inlining, common sub-expression elimination, code specialisation). Then, every block is translated into a step function (e.g., a C function). This intermediate language has been designed to facilitate the generation of code for a real-time OS and a multi-core target. This work exploits two older results: the article of Caspi et al. 27 that introduces an object representation for synchronous nodes and a “scheduling policy” that specifies how their methods may be called, and; the work of Pouzet et al. 42 on the calculation of input/output relations to merge calculations. We are preparing and article on this subject.

Scheduling and code generation for periodic streams:   

In this approach, the top-level node of a Lustre program is distinguished from inner nodes. It may contain special annotations to specify the triggering and other details of node instances from which separate “tasks” are to be generated. Special operators are introduced to describe the buffering between top-level instances. Notably, different forms of the when and current operators are provided. Some of the operators are under-specified and a constraint solver is used to determine their exact meaning, that is, whether the signal is delayed by zero, one, or more cycles of the receiving clock, which depends on the scheduling of the source and destination nodes. Scheduling is formalized as a constraint solving problem based on latency constraints between some pairs of input/outputs that are specified by the designer.

This year we continued work on a new prototype compiler for a synchronous language with clock rates and a model where “synchronous” does not necessarily mean “simultaneous”. This year, we made progress on constraining latency across chains of components, treating cycles in the dataflow graph, and generating imperative code.

Embedded controllers often contain calculation sequences whose end-to-end latency is critical to application performance. This is notably the case for control calculations that occur between input acquisition and output emission. We devised and implemented an algorithm for expressing and constraining this latency as part of the overall scheduling problem. The difficulty is to treat the causality between and within instants, and to properly handle rate changes across sequences. This algorithm has been implemented in our prototype compiler. We also wrote a visualization tool for validating and explaining the algorithm. This tool helped us to find many bugs in the original implementation. It also appears to be a useful means of analyzing application behavior. We also adapted our prototype with support for atomic sequences.

Our algorithm worked well on a mid-sized case study, but upon attempting to apply it to a production problem, we had many problems with cyclic dependencies. In an attempt to visualize the problem we contributed algorithms to the ocamlgraph library and developed some simple tools (undotter and subdotter). We then surveyed the literature on heuristics for removing cycles by calculating feedback arc sets. Good heuristics are essential since the problem is NP-complete and our graphs are quite large. We adapted the “FASH” algorithm  33, 32 by extending it with weights and irreversible arcs and implemented it in OCaml. This approach seems to work quite well, but we are still experimenting with it.

We extended our compiler by implementing standard techniques for constraining and load-balancing resources. We extended the standard code generation scheme  22 to treat rate-based components.

This work is funded by a direct industrial contract with Airbus.

Distribution of the language

The language, its compiler and examples (release 2.1) are now on GitHub. It is also available as an OPAM package. All the installation machinery has been greatly simplified.

Set-based simulation of Zelus programs

In collaboration with Francois Bidet (PhD. student under the supervision of Sylvie Putot and Eric Goubault from Ecole polytechnique), we are developing a method to perform set-based simulation of Zelus program. Set-based simulation goes beyond concrete simulation (the default simulation mode of all existing hybrid system modeling languages). Instead of computing one trajectory, it computes a set of trajectories or flowpipes at once, replacing a possibly unbounded number of concrete simulations. It is also able to deal with models with partially known parameters and inputs.

Very little tools currently deal with models expressed modularily (as the parallel and hierarchical composition of subsystems, with function application and the mix between a software model and ODEs, for example). A prototype is under way. Set based simulation is done on the intermediate language generated by Zelus, that is a collection of tarnsition functions acting on a state.

Property Based Testing of Hybrid Programs

Property-based program testing involves checking an executable specification by running many tests. We build on the work of Georgios Fainekos and Alexandre Donzé, and take inspiration from earlier work by Nicolas Halbwachs, to write a Zélus library of synchronous observers with a quantitative semantics that can be used to specify properties of a system under test. We implemented several optimization algorithms for producing test cases, some of which are gradient-based. This year, we have studied the use SUNDIALS CVODEs (sensitivity analysis) to find more falsification examples and faster.

7.7.1 Reactive Probabilistic Programming

Synchronous languages were introduced to design and implement real-time embedded systems with a (justified) enphasis on determinacy. Yet, they interact with a physical environment that is only partially known and are implemented on architectures subject to failures and noise (e.g., channels, variable communication delays or computation time). Dealing with uncertainties is useful for online monitoring, learning, statistical testing or to build simplified models for faster simulation. Actual synchronous and languages provide limited support for modeling the non-deterministic behaviors that are omnipresent in embedded systems.

We previously designed ProbZelus, an extension of Zelus with probabilistic constructs to model uncertainties and perform inference-in-the-loop. Importanty, we introduced a novel streaming delayed sampling implementation which enables partial exact inference over infinite streams in bounded memory for a large class of models.

Continuing the collaboration with Louis Mandel (IBM), Erik Atkinson, Michael Carbin and Charles Yuan (MIT), we found conditions on a reactive probabilistic model’s execution under which delayed sampling will execute in bounded memory. The two conditions are dataflow properties of the core operations of delayed sampling: the m-consumed property and the unseparated paths property. A showed that a program executes in bounded memory under delayed sampling if, and only if, it satises the m-consumed and unseparated paths properties. We proposed a static analysis that abstracts over these properties to soundly ensure that any program that passes the analysis satises these properties, and thus executes in bounded memory under delayed sampling.

The main article Statically Bounded-Memory Delayed Sampling for Probabilistic Streams was presented at the Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2021) and published in the Proceedings of the ACM on Programming Languages (PACMPL) 12. A short version was also presented at the international conference on Probabilistic Programming (PROGPROB 2021) 19.

7.7.2 Compiling Stan to Generative Probabilistic Languages

Stan is a probabilistic programming language that is popular in the statistics community, with a high-level syntax for expressing probabilistic models. Stan differs by nature from generative probabilistic programming languages like Church,Anglican, or Pyro. We proposed a comprehensive compilation scheme to compile any Stan model to a generative language and proved its correctness. We use our compilation scheme to build two new backends for the Stanc3 compiler targeting Pyro and NumPyro. Experimental results show that the NumPyro backend yields significant speedup compared to Stan on existing benchmarks.

Our compiler leverages the rich set of Pyro and Numpyro features for Stan users. Building on Pyro we thus extended Stan with support for explicit variational inference guides and deep probabilistic models, i.e., probabilistic models involving neural networks. Leveraging NumPyro runtime we show that using our recently proposed compiler from Stan to Pyro, Stan users can easily try the set of algorithms implemented in Pyro for black-box variational inference.

The compiler is available on GitHub and the main article Compiling Stan to Generative Probabilistic Languages and Extension to Deep Probabilistic Programming was presented at the Conference on Programming Language Design and Implementation (PLDI 2021) 14. The article Automatic Guide Generation for Stan via NumPyro was accepted as an oral presentation at the international conference on Probabilistic Programming (PROGPROB 2021) 19.

7.8.1 Lale: Gradual Automation

Automated machine learning (AutoML) can make data scientists more productive. But if machine learning is totally automated, that leaves no room for data scientists to apply their intuition. Hence, data scientists often prefer not total but gradual automation, where they control certain choices and AutoML explores the rest. We thus proposed Lale, a sklearn-compatible AutoML library based on a small set of orthogonal combinators for composing machine- learning operators into pipelines. Lale then compiles pipelines and associated hyperparameter schemas to search spaces for AutoML optimizers.

Lale is gradual, letting users specify only what they want while reusing and automating the rest. For instance, Lale comes with an extensive library of reusable hyperparameter schemas for many popular operators, so users rarely need to write their own schemas; but it also makes it easy to customize schemas when desired. There are Lale optimizer backends for multiple optimizers: Hyperopt; sklearn’s GridSearchCV and HalvingGridSearchCV; ADMM; SMAC; and Hyberband.

Lale is available on GitHub and the main article Pipeline Combinators for Gradual AutoML was presented at the Conference on Neural Information Processing Systems (NeurIPS'21) 15

7.8.2 Extracting Hyperparameters Constraints from Code

In Lale, each machine learning operator is associated to a schema that captures its hyperparameters and correctness constraints that cut across multiple hyperparameters and/or data. Violating these constraints causes runtime exceptions, but they are usually documented only informally or not at all. We proposed an interprocedural weakest-precondition analysis for Python code to extract hyperparameter constraints. The analysis is mostly static, but to make it tractable for typical Python idioms in machine-learning libraries, it selectively switches to the concrete domain for some cases.

The paper Extracting Hyperparameter Constraints from Code was presented at the ICLR 2021 Workshop on Security and Safety in Machine Learning Systems 21.

Collaboration with Airbus

Participants: Timothy Bourke, Marc Pouzet.

Our work on multi-clock Lustre programs is funded by a contract with Airbus.

9.1.1 Participation in other International Programs

9.2.1 FP7 & H2020 projects

9.3.1 ANR

The ANR JCJC project “FidelR” led by T. Bourke began in 2020 and continues for four years.

9.3.2 FUI: Fonds unique interministériel

9.3.3 Programme d'Investissements d'Avenir (PIA)

9.3.4 Others

10.1.1 Scientific events: organisation

10.1.2 Scientific events: selection

10.1.3 Journal

10.1.4 Invited talks

• Guillaume Baudart was an invited speaker at the Workshop on Probabilistic Interactive and Higher-Order Computation (PIHOC 2021).
• Guillaume Baudart was an invited speaker at the Inria Paris, demi-heure de science seminar.
• Timothy Bourke gave the keynote talk at the Workshop on Reactive and Event-Based Languages and Systems (REBLS 2021).
• Marc Pouzet was invited speaker by the formal method group of NASA Langley, January 2021.

10.1.5 Research administration

• Timothy Bourke was a jury member for the Paris Centre CRCN/ISFP concours.
• Timothy Bourke participated in several thesis monitoring committees.
• Marc Pouzet was jury member of the Phd. thesis of Vincent Lampietro (Univl. Montpellier, December 2021.

10.2.1 Teaching

• Marc Pouzet is Director of Studies for the CS department, at ENS.
• Licence : Marc Pouzet & Timothy Bourke : “Operating Systems” (L3), Lectures and TDs, ENS, France.
• Master : Marc Pouzet , Guillaume Baudart , & Timothy Bourke , “Models and Languages for Programming Reactive Systems” (M1), Lectures and TDs, ENS, France.
• Master: Marc Pouzet & Timothy Bourke : “Synchronous Systems” (M2), Lectures and TDs, MPRI, France
• Master: Marc Pouzet : “Synchronous Reactive Languages” (M2), Lectures, Master COMASIC (École Polytechnique) and FIL (Université Paris-Sud, Saclay), France
• Master: Marc Pouzet "The Elements of Computing Systems". Cycle pluridisciplinaire d'études supérieures (CPES), L2.
• Master: Timothy Bourke : “A Programmer’s introduction to Computer Architectures and Operating Systems" (M1), École Polytechnique, France
• Master: Timothy Bourke presented two lectures and TPs on Synchronous Languages in Carlos Agon's course on concurrent models at Sorbonne Université.
• Master: Guillaume Baudart : “Synchronous Programming” (M2), TDs, Université de Paris, France
• Master: Guillaume Baudart : “Probabilistic Programming Languages” (M2), Lectures and TDs, MPRI, France
• Aggregation: Guillaume Baudart : “Introduction to Software Engineering” (préparation à l'aggrégation d'informatique), Lectures and TDs, France
• Bachelor: Timothy Bourke : “A Programmer’s introduction to Computer Architectures and Operating Systems" (L2), École Polytechnique, France
• Internships Timothy Bourke & Guillaume Baudart participated in reviewing the L3 and M1 internships of students at the ENS, France.

10.2.2 Supervision

• PhD in progress: Paul Jeanmaire , 2nd year, supervised by Timothy Bourke and Marc Pouzet .
• PhD in progress: Baptiste Pauget , 2nd year, supervised by Marc Pouzet .
• PhD in progress: Basile Pesin , 2nd year, supervised by Timothy Bourke and Marc Pouzet .
• PhD in progress: Astyax Nourel , 1st year, supervised by Adrien Guatto (IRIF, Univ. of Paris) and Marc Pouzet .
• Master: Antonin Reitz , M2 research internship, supervised by Marc Pouzet (March-August 2021).
• Master: Reyan Tekin , M2 research internship, supervised by Guillaume Baudart and Marc Pouzet (March-August 2021).

10.3.1 Education

• Timothy Bourke presented at a meeting of the IEEE Student Chapter at the École polytechnique.

International journals

• 12 articleBest paperE.Eric Atkinson, G.Guillaume Baudart, L.Louis Mandel, C.Charles Yuan and M.Michael Carbin. Statically bounded-memory delayed sampling for probabilistic streams.Proceedings of the ACM on Programming Languages5OOPSLAOctober 2021, 1-28
  HALDOIback to text
• 13 articleT.Timothy Bourke, P.Paul Jeanmaire, B.Basile Pesin and M.Marc Pouzet. Verified Lustre Normalization with Node Subsampling.ACM Transactions on Embedded Computing Systems (TECS)205sOctober 2021, 1-25
  HALDOIback to textback to text

International peer-reviewed conferences

• 14 inproceedingsBest paperG.Guillaume Baudart, J.Javier Burroni, M.Martin Hirzel, L.Louis Mandel and A. 2.Avraham 2021 Shinnar. Compiling Stan to generative probabilistic languages and extension to deep probabilistic programming.PLDI '21 - 42nd ACM SIGPLAN International Conference on Programming Language Design and ImplementationVirtual, CanadaACMJune 2021, 497-510
  HALDOIback to text
• 15 inproceedingsG.Guillaume Baudart, M.Martin Hirzel, K.Kiran Kate, P.Parikshit Ram, A.Avraham Shinnar and J.Jason Tsay. Pipeline Combinators for Gradual AutoML.NeurIPS 2021 - Thirty-fifth Conference on Neural Information Processing SystemsVirtual, FranceDecember 2021
  HALback to text
• 16 inproceedingsL.Lorenzo Chelini, A.Andi Drebes, O.Oleksandr Zinenko, A.Albert Cohen, N.Nicolas Vasilache, T.Tobias Grosser and H.Henk Corporaal. Progressive Raising in Multi-level IR.CGO 2021 : International Symposium on Code Generation and OptimizationInternational Conference on Code Generation and Optimization (CGO)Seoul / Virtual, South KoreaFebruary 2021
  HAL

National peer-reviewed Conferences

• 17 inproceedingsT.Timothy Bourke, P.Paul Jeanmaire, B.Basile Pesin and M.Marc Pouzet. Verified normalization of the Lustre language.JFLA 2021 - 32ème Journées Francophones des Langages ApplicatifsJFLA 2021 - 32ème Journées Francophones des Langages ApplicatifsEn ligne, FranceApril 2021, 117-133
  HAL

Conferences without proceedings

• 18 inproceedingsE.Eric Atkinson, G.Guillaume Baudart, L.Louis Mandel, C.Charles Yuan and M.Michael Carbin. Checking Bounded-Memory Execution for Delayed Sampling on Probabilistic Streams.PROBPROG 2021 - Third International Conference on Probabilistic ProgrammingVirtual, United StatesOctober 2021
  HAL
• 19 inproceedingsG.Guillaume Baudart and L.Louis Mandel. Automatic Guide Generation for Stan via NumPyro.PROBPROG 2021 - Third International Conference on Probabilistic ProgrammingVirtual, United StatesOctober 2021
  HALback to textback to text
• 20 inproceedingsG.Georgios Mavroudeas, G.Guillaume Baudart, A.Alan Cha, M.Martin Hirzel, J. A.Jim A Laredo, M.Malik Magdon-Ismail, L.Louis Mandel and E.Erik Wittern. Learning GraphQL Query Cost.ASE 2021 - IEEE/ACM International Conference on Automated Software Engineering -- Industry ShowcaseMelbourne / Virtuel, AustraliaNovember 2021
  HALback to text
• 21 inproceedingsI.Ingkarat Rak-Amnouykit, A.Ana Milanova, G.Guillaume Baudart, M.Martin Hirzel and J.Julian Dolby. Extracting Hyperparameter Constraints from Code.ICLR Workshop on Security and Safety in Machine Learning SystemsVirtual, United StatesMay 2021
  HALback to text