Guillaume Baudart

École normale supérieure
PARKAS Team

About

I am a PhD candidate in the Parkas team of the Computer Science department (DI) at École normale supérieure in Paris under the supervision of Marc Pouzet and Timothy Bourke (CV). My research focuses on systems mixing discrete logic and real-time requirements and in particular the link between continuous- and discrete-time. I have worked on the following topics:

  • The Quasi-Synchronous Abstraction is a discrete time abstraction proposed for analysing quasi-periodic architectures where computing units execute almost periodically. We showed that this abstraction is not sound for general systems and give necessary and sufficient conditions to recover soundness [6].
  • Loosely Time-Triggered Architectures (LTTAs) are a proposal for implementing synchronous programs over networks of embedded controllers [3]. We showed that the deployment of a synchronous application can be modeled using a synchronous framework and present controller models that can be compiled for execution [4,5].
  • CloudLens a Scripting Language for Analysing Semi-Structured Data. We designed a scripting language, built on top of JavaScript, with dedicated streaming features for analysing streams of raw data [7]. A CloudLens script extracts information from the data and either report error states (monitoring), or find the causes of a crash (troubleshooting).
  • Antescofo as a ReactiveML Embedded Domain Specific Language (eDSL). We gave a synchronous semantics to the Antescofo language, a DSL for authoring mixed music, and an alternative implementation of the sequencer based on an embedding inside a synchronous language, ReactiveML [2]. We used this embedding to allow live coding with Antescofo [1].

Contact

Email:
guillaume [dot] baudart [at] ens.fr
Phone:
+33 (0)1 44 32 21 18
Address:
Département Informatique (DI)
École normale supérieure
45 rue d'Ulm, 75005 Paris, France
Office:
S13, Saumon corridor,
Floor -1, Rataud wing

Publications

  1. CloudLens, A Scripting Language for Semi-Structured Data Analysis,
    with Louis Mandel, Olivier Tardieu, and Mandana Vaziri
    Journées Francophones des Langages Applicatifs (JFLA'17), Jan. 2017 (to appear)
    [ bibtex | paper ]

    We present CloudLens, as scripting language based on JavaScript for semi-structured textual data analysis, like log files produced by a cloud application (this paper is in french).

    Lors de la mise au point d'applications qui s'exécutent dans le nuage, les programmeurs ne peuvent souvent que tracer l'exécution de leur code en multipliant les impressions. Cette pratique génère des quantités astronomiques de fichiers de traces qu'il faut ensuite analyser pour trouver les causes d'un bogue. De plus, les applications combinent souvent de nombreux micro-services, et les programmeurs n'ont qu'un contrôle partiel du format des données qu'ils manipulent. Cet article présente CloudLens, un langage dédié à l'analyse de ce type de données dites semi-structurées. Il repose sur un modèle de programmation flot de données qui permet à la fois d'analyser les sources d'une erreur et de surveiller une application en cours d'exécution.

  2. Soundness of the Quasi-Synchronous Abstraction,
    with Timothy Bourke and Marc Pouzet
    International Conference on Formal Methods in Computer-Aided Design (FMCAD'16), Oct. 2016
    [ bibtex | paper ]

    We show that the 'quasi-synchronous' abstraction is not sound for general systems of more than two processes and propose necessary and sufficient conditions to recover soundness.

    Many critical real-time embedded systems are implemented as a set of processes that execute periodically with bounded jitter and communicate with bounded transmission delay. The 'quasi-synchronous' abstraction was introduced by P. Caspi for model-checking the safety properties of applications running on such systems. The simplicity of the abstraction is appealing: the only events are process activations; logical steps account for transmission delays; and no process may be activated more than twice between two successive activations of any other.

    We formalize the relation between the real-time model and the quasi-synchronous abstraction by introducing the notion of a unitary discretization. Even though the abstraction has been applied several times in the literature, we show, surprisingly, that it is not sound for general systems of more than two processes. Our central result is to propose necessary and sufficient conditions on both communication topologies and timing parameters to recover soundness.

  3. Loosely Time-Triggered Architectures: Improvements and Comparisons,
    with Albert Benveniste and Timothy Bourke
    International Conference on Embedded Software (EMSOFT'15), Oct. 2015
    [ bibtex | paper ]

    An LTTA is the combinaison of a Quasi-Periodic architecture with a protocol for deploying synchronous applications. We present two protocols in a synchronous framework and compare this approach to Clock-Synchronization.

    Loosely Time-Triggered Architectures (LTTAs) are a proposal for constructing distributed embedded control systems. They build on the quasi-periodic architecture, where computing units execute 'almost periodically', by adding a thin layer of middleware that facilitates the implementation of synchronous applications.

    We show how the deployment of a synchronous application on a quasi-periodic architecture can be modeled using a synchronous formalism. Then we detail two protocols, Back-Pressure LTTA, reminiscent of elastic circuits, and Time-Based LTTA, based on waiting. Compared to previous work, we present controller models that can be compiled for execution and a simplified version of the Time-Based protocol. We also compare the LTTA approach with architectures based on clock synchronization.

  4. Loosely Time-Triggered Architectures: Improvements and Comparisons,
    with Albert Benveniste and Timothy Bourke
    ACM Transaction on Embedded Computing Systems (TECS), Vol.15 N.4 August 2016
    [ bibtex | paper | website ]

    Journal version of the EMSOFT'15 paper on LTTAs with and overview of the Zélus language and two optimizations for systems using broadcast communication.

    Loosely Time-Triggered Architectures (LTTAs) are a proposal for constructing distributed embedded control systems. They build on the quasi-periodic architecture, where computing units execute 'nearly periodically', by adding a thin layer of middleware that facilitates the implementation of synchronous applications.

    In this paper, we show how the deployment of a synchronous application on a quasi-periodic architecture can be modeled using a synchronous formalism. Then we detail two protocols, Back-Pressure LTTA, reminiscent of elastic circuits, and Time-Based LTTA, based on waiting. Compared to previous work, we present controller models that can be compiled for execution, a simplified version of the Time-Based protocol and optimizations for systems using broadcast communication. We also compare the LTTA approach with architectures based on clock synchronization.

  5. A Unifying View of Loosely Time-Triggered Architectures,
    with Albert Benveniste, Anne Bouillard and Paul Caspi
    INRIA Research Report RR-8494, Mar. 2014
    [ bibtex | paper ]

    This research report is a corrected version of a paper which appeared at EMSOFT'2010 with the same title. It presents the two LTTA protocols, Back-Pressure and Time-Based, in a single unified Petri-Net framework.

    Cyber-Physical Systems require distributed architectures to support safety critical real-time control. Hermann Kopetz' Time-Triggered Architecture (TTA) has been proposed as both an architecture and a comprehensive paradigm for systems architecture, for such systems. TTA offers the programmer a logical discrete time compliant with synchronous programming, together with timing bounds. A clock synchronization protocol is required, unless the local clocks used themselves provide the recquired accuracy. To relax the strict requirements on synchronization imposed by TTA, Loosely Time-Triggered Architectures (LTTA) have been proposed. In LTTA, computation and communication units are all triggered by autonomous, unsynchronized, clocks. Communication media act as shared memories between writers and readers and communication is non blocking. This is at the price of communication artifacts (such as duplication or loss of data), which must be compensated for by using some "LTTA protocol". In this paper we pursue our previous work by providing a unified presentation of the two variants of LTTA (token- and time-based), with simplified analyses. We compare these two variants regarding performance and robustness and we provide ways to combine them.

    This report was prepared for a lecture in Gérard Berry's seminar series at the Collège de France, March 5, 2014; it is a corrected version of a paper, which appeared at Emsoft'2010. It is dedicated to our close friend Paul Caspi who died in April 2012.

  6. A Synchronous Embedding of Antescofo, a Domain-Specific Language for Interactive Mixed Music,
    with Florent Jacquemard, Louis Mandel and Marc Pouzet
    International Conference on Embedded Software (EMSOFT'13), Sept. 2013
    [ bibtex | paper | website ]

    This article presents a synchronous semantics for the core of the Antescofo language, a DSL for authoring mixed music, and an alternative implementation based on an embedding inside a synchronous language, ReactiveML.

    Antescofo is recently developed software for musical score following and mixed music: it automatically, and in real-time, synchronizes electronic instruments with a musician playing on a classical instrument. Therefore, it faces some of the same major challenges as embedded systems.

    The system provides a programming language used by composers to specify musical pieces that mix interacting electronic and classical instruments. This language is developed with and for musicians and it continues to evolve according to their needs. Yet its semantics has only recently been formally defined. This paper presents a synchronous semantics for the core language of Antescofo and an alternative implementation based on an embedding inside an existing synchronous language, namely ReactiveML. The semantics reduces to a few rules, is mathematically precise and leads to an interpretor of only a few hundred lines. The efficiency of this interpretor compares well with that of the actual implementation: on all musical pieces we have tested, response times have been less than the reaction time of the human ear. Moreover, this embedding permitted the prototyping of several new programming constructs, some of which are described in this paper.

  7. Programming Mixed-Music in ReactiveML,
    with Louis Mandel and Marc Pouzet
    Workshop on Functional Art, Music, Modeling and Design (FARM'13), Sept. 2013
    [ bibtex | paper | website ]

    A tutorial on how to program mixed music in ReactiveML through several examples: frère Jacques, a very simple musical round; live coding using the Antescofo library; and Steve Reich's Piano Phase.

    Mixed music is about live musicians interacting with electronic parts which are controlled by a computer during the performance. It allows composers to use and combine traditional instruments with complex synthesized sounds and other electronic devices. There are several languages dedicated to the writing of mixed music scores. Among them, the Antescofo language coupled with an advanced score follower allows a composer to manage the reactive aspects of musical performances: how electronic parts interact with a musician. However these domain specific languages do not offer the expressiveness of functional programming.

    We embed the Antescofo language in a reactive functional programming language, ReactiveML. This approach offers to the composer recursion, higher order, inductive types, as well as a simple way to program complex reactive behaviors thanks to the synchronous model of concurrency on which ReactiveML is built. This article presents how to program mixed music in ReactiveML through several examples.

Talks

Complete list
  • Synchron'16 (Dec. 2016, Bamberg, Germany)
    CloudLens, a scripting language for analysing textual semi-structured data
    [ slides ]
  • FMCAD'16 (Oct. 2016, Montain View, USA)
    Soundness of the Quasi-Synchronous Abstraction
    [ paper | slides ]
  • EMSOFT'15 (Oct. 2015, Amsterdam, The Netherlands)
    Loosely Time-Triggered Architectures: Improvements and Comparisons
    [ paper | slides ]
  • G. Berry Seminar (Dec. 2013, Collège de France, Paris, France)
    The Antescofo Language in ReactiveML
    [ slides ]
  • EMSOFT'13 (Sept. 2013, Montreal, Canada)
    A Synchronous Embedding of Antescofo, a Domain-Specific Language for Interactive Mixed Music
    [ paper | slides | poster ]
  • FARM'13 (Sept. 2013, Boston, USA)
    Programming Mixed-Music in ReactiveML
    [ paper | slides | video ]

Teaching

I teach at university Paris 6 (UPMC) in first and second year undergraduate courses.

2015 — 2016
Discrete Structures
10h — second year
2014 — 2016
Introduction to Algorithmic
40h — second year
Introduction to Python Programming
20h — first year
2013 — 2014
Introduction to C Programming
42h — first year
Recursive Programming in Scheme
30h — first year