2024

• ELS 2024
• Reference: BibTeX
• The internal architecture of Declt, our reference manual generator for Common Lisp libraries, is currently evolving towards a three-stages pipeline in which the information gathered for documentation purposes is first reified into a formalized set of object-oriented data structures. A side-effect of this evolution is the ability to dump that information for other purposes than documentation. We demonstrate this ability applied to the complete Quicklisp ecosystem. The resulting "cohort" includes more than half a million programmatic definitions, and can be used to gain insight into the morphology of Common Lisp software.

2023

• CAIP 2023
• Article: PDF, HTML
• Reference: BibTeX
• Hierarchical representations are very convenient tools when working with images. Among them, the alpha-tree is the basis of several powerful hierarchies used for various applications such as image simplification, object detection, or segmentation. However, it has been demonstrated that these tasks are very sensitive to the noise corrupting the image. While the quality of some alpha-tree applications has been studied, including some with noisy images, the noise impact on the whole structure has been little investigated. Thus, in this paper, we examine the structure of alpha-trees built on images corrupted by some noise with re- spect to the noise level. We compare its effects on constant and natural images, with different kinds of content, and we demonstrate the relation between the noise level and the distribution of every alpha-tree node depth. Furthermore, we extend this study to the node persistence under a given energy criterion, and we propose a novel energy definition that allows assessing the robustness of a region to the noise.

• TUG 2023
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Live recording
• We present ETAP, a platform designed to support both demonstration of, and experimentation with digital typesetting, interactively, and in real-time. ETAP provides a GUI which currently focuses on all aspects involved in paragraph formatting. A number of pre-processing features can be switched on or off (hyphenation, kerning, ligaturing, etc.). A specific paragraph formatting scheme may be selected from a pool of ready-made algorithms, and adding new algorithms to that pool is easy. Each algorithm comes with its own set of configuration parameters, and the GUI allows you to tweak those parameters and observe the effects in real-time. ETAP may also be used without, or in parallel with the GUI. While the application is running, the whole programmatic infrastructure is manipulable from a command-line interface. This allows inspection of the various typesetting objects normally displayed by the GUI, and also to perform computations with them, for example, data collection and statistical measurements.

• GRETSI 2023
• Article: PDF, HTML
• Reference: BibTeX
• L’arbre alpha est une représentation hiérarchique utilisée dans divers traitements d’une image tels que la segmentation ou la simplification. Ces traitements sont néanmoins sensibles au bruit, ce qui nécessite parfois de les adapter. Or, l’influence du bruit sur la structure de l’arbre alpha n’a été que peu étudiée dans la littérature. Ainsi, nous proposons une étude de l’impact du bruit en fonction de son niveau sur la structure de l’arbre. De plus, nous étendons cette étude à la persistance des nœuds de l’arbre en fonction d’une énergie donnée, et nous concluons que certaines fonctionnelles sont plus sensibles au bruit que d’autres.

• ELS 2023
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Live recording
• In traditional object-oriented languages, the dynamic dispatch algorithm is hardwired to select and execute the most specific method in a polymorphic call. In CLOS, the Common Lisp Object System, an abstraction known as "method combinations" allows the programmer to define their own dispatch scheme. When Common Lisp was standardized, method combinations were not mature enough to be fully specified. In 2018, using SBCL as a research vehicle, we analyzed the unfortunate consequences of this under-specification and proposed a layer on top of method combinations designed to both correct a number of observed behavioral inconsistencies, and propose an extension called "alternative combinators". Following this work, SBCL underwent a number of internal changes that fixed the reported inconsistencies, although in a way that hindered further experimentation. In this paper, we analyze SBCL's new method combinations implementation and we propose an alternative design. Our solution is standard-compliant so any Lisp implementation can potentially use it. It is also based on the MOP, meaning that it is extensible, which restores the opportunity for further experimentation. In particular, we revisit our former "alternative combinators" extension, broken after 2018, and demonstrate that provided with this new infrastructure, it can be re-implemented in a much simpler and non-intrusive way.

2022

• GPCE 2022
• Article: PDF, HTML
• Reference: BibTeX
• Generic programming is a powerful paradigm abstracting data structures and algorithms to improve their reusability as long as they respect agiven interface. Coupled with a performance-driven language, it is a paradigm of choice for scientific libraries where the implementation of manipulated objects may change in function of their use case or for performance purposes. In those performance-driven languages, genericity is often implemented statically to perform some optimization at compile time. This does not fit well with the dynamism needed to handle objects which may only be known at runtime. Thus, in this article, we evaluate a model that couples static genericity with a dynamic model based on type erasure in the context of image processing. Its cost is assessed by comparing the performance of the implementation of some image processing algorithms in C++ and Rust, two performance-driven languages supporting the genericity paradigm. We finally show that the knowledge of some information at compile time is more important than others, but also that the runtime overhead depends on the algorithmic scheme.

• GRETSI 2022
• Reference: BibTeX
• La généricité est un paradigme puissant dont l'usage permet d'implémenter un unique algorithme et de l'exécuter sur différents types de données. De ce fait, il est très utilisé lors du développement d'une bibliothèque scientifique, notamment en traitement d'images où les algorithmes peuvent s'appliquer à différents types d'images. Le langage C++ est un langage de choix pour ce genre de bibliothèque. Il supporte ce paradigme et ses applications sont performantes compte tenu de sa nature compilée. Néanmoins, contrairement à des langages dynamiques tels que Python ou Julia, ses capacités en matière d'interactivité, utiles lors des étapes de prototypage d'algorithmes, sont limitées en raison de sa nature statique. Nous proposons donc dans cet article une revue des différentes techniques qui permettent d'utiliser à la fois le polymorphisme statique et dynamique, puis nous évaluons le co\^ut du transfert d'information statique vers des informations connues à l'exécution. En particulier, nous montrons que certaines informations d'une image sont plus importantes que d'autres en matière de performance, et que le surco\^ut dépend aussi de l'algorithme utilisé.

• GRETSI 2022
• Reference: BibTeX
• Le niveau de bruit est une information importante pour certaines applications de traitement d'image telles que la segmentation ou le débruitage. Par le passé, nous avons proposé une méthode pour estimer ce niveau de bruit en s'adaptant au contenu d'une image en niveau de gris et nous avons montré que ses performances dépassent celle de l'état de l'art. Dans cet article, nous proposons une extension de cette méthode aux images couleurs dont les valeurs multivariées, dénuées de relation d'ordre naturelle, impliquent de nouvelles problématiques. Afin de les résoudre, nous utilisons deux outils provenant de la morphologie mathématique: l'arbre des formes multivarié et l'apprentissage de treillis complet. Enfin, nous confirmons les conclusions de nos précédents travaux pour l'estimation de la fonction de niveau de bruit couleur, montrant que l'adaptation au contenu d'une image donne de meilleures performances que l'utilisation de blocs carrés.

• ICPR 2022
• Reference: BibTeX
• Noise level information is crucial for many image processing tasks, such as image denoising. To estimate it, it is necessary to find homegeneous areas within the image which contain only noise. Rank-based methods have proven to be efficient to achieve such a task. In the past, we proposed a method to estimate the noise level function (NLF) of grayscale images using the tree of shapes (ToS). This method, relying on the connected components extracted from the ToS computed on the noisy image, had the advantage of being adapted to the image content, which is not the case when using square blocks, but is still restricted to grayscale images. In this paper, we extend our ToS-based method to color images. Unlike grayscale images, the pixel values in multivariate images do not have a natural order relationship, which is a well-known issue when working with mathematical morphology and rank statistics. We propose to use the multivariate ToS to retrieve homogeneous regions. We derive an order relationship for the multivariate pixel values thanks to a complete lattice learning strategy and use it to compute the rank statistics. The obtained multivariate NLF is composed of one NLF per channel. The performance of the proposed method is compared with the one obtained using square blocks, and validates the soundness of the multivariate ToS structure for this task.

• ELS 2022
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• We present the early development stages of ETAP, a platform for experimenting with typesetting algorithms. The purpose of this platform is twofold: while its primary objective is to provide building blocks for quickly and easily designing and testing new algorithms (or variations on existing ones), it can also be used as an interactive, real time demonstrator for many features of digital typography, such as kerning, hyphenation, or ligaturing.

2021

• ELS 2021
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Quicklisp is a library manager working with your existing Common Lisp implementation to download and install around 2000 libraries, from a central archive. Quickref, an application itself written in Common Lisp, generates, automatically and by introspection, a technical documentation for every library in Quicklisp, and produces a website for this documentation. In this paper, we present a corpus processing and analysis pipeline for Quickref. This pipeline consists of a set of natural language processing blocks allowing us to analyze Quicklisp libraries, based on natural language contents sources such as README files, docstrings, or symbol names. The ultimate purpose of this pipeline is the generation of a keyword index for Quickref, although other applications such as word clouds or topic analysis are also envisioned.

2020

• Habilitation Memoir
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX

2019

• TUG 2019
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Quickref is a global documentation project for the Common Lisp ecosystem. It creates reference manuals automatically by introspecting libraries and generating corresponding documentation in Texinfo format. The Texinfo files may subsequently be converted into PDF or HTML. Quickref is non-intrusive: software developers do not have anything to do to get their libraries documented by the system. Quickref may be used to create a local website documenting your current, partial, working environment, but it is also able to document the whole Common Lisp ecosystem at once. The result is a website containing almost two thousand reference manuals. Quickref provides a Docker image for an easy recreation of this website, but a public version is also available and actively maintained. Quickref constitutes an enormous and successful stress test for Texinfo. In this paper, we give an overview of the design and architecture of the system, describe the challenges and difficulties in generating valid Texinfo code automatically, and put some emphasis on the currently remaining problems and deficiencies.

• ELS 2019
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Quickref is a global documentation project for Common Lisp software. It builds a website containing reference manuals for Quicklisp libraries. Each library is first compiled, loaded, and introspected. From the collected information, a Texinfo file is generated, which is then processed into HTML. Because of the large number of libraries in Quicklisp, doing this sequentially may require several hours of processing. We report on our experiments parallelizing Quickref. Experimental data on the morphology of Quicklisp libraries has been collected. Based on this data, we are able to propose a number of parallelization schemes that reduce the total processing time by a factor of 3.8 to 4.5, depending on the exact situation.

• ELS 2019
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• We present an efficient and highly optimized implementation of destructuring-case in Common Lisp. This macro allows the selection of the most ppropriate destructuring lambda list of several given based on structure and types of data at run-time and thereafter dispatches to the corresponding code branch. We examine an optimization technique, based on finite automata theory applied to conditional variable binding and execution, and type-based pattern matching on Common Lisp sequences. A risk of inefficiency associated with a naive implementation of destructuring-case is that the candidate expression being examined may be traversed multiple times, once for each clause whose format fails to match, and finally once for the successful match. We have implemented destructuring-case in such a way to avoid multiple traversals of the candidate expression. This article explains how this optimization has been implemented.

• ELS 2019
• Article: PDF, HTML
• Reference: BibTeX
• We present here our partial implementation of Baker’s decision procedure for SUBTYPEP. In his article "A Decision Procedure for Common Lisp’s SUBTYPEP Predicate", he claims to provide implementation guidelines to obtain a SUBTYPEP more accurate and as efficient as the average implementation. However, he did not provide any serious implementation and his description is sometimes obscure. In this paper we present our implementation of part of his procedure, only supporting primitive types, CLOS classes, member, range and logical type specifiers. We explain in our words our understanding of his procedure, with much more detail and examples than in Baker’s article. We therefore clarify many parts of his description and fill in some of its gaps or omissions. We also argue in favor and against some of his choices and present our alternative solutions. We further provide some proofs that might be missing in his article and some early efficiency results. We have not released any code yet but we plan to open source it as soon as it is presentable.

• ACM Transactions on Computational Logic
• Reference: BibTeX
• Binary Decision Diagrams (BDDs) and in particular ROBDDs (Reduced Ordered BDDs) are a common data structure for manipulating Boolean expressions, integrated circuit design, type inferencers, model checkers, and many other applications. Although the ROBDD is a lightweight data structure to implement, the behavior, in terms of memory allocation, may not be obvious to the program architect. We explore experimentally, numerically, and theoretically the typical and worst-case ROBDD sizes in terms of number of nodes and residual compression ratios, as compared to unreduced BDDs. While our theoretical results are not surprising, as they are in keeping with previously known results, we believe our method contributes to the current body of research by our experimental and statistical treatment of ROBDD sizes. In addition, we provide an algorithm to calculate the worst-case size. Finally, we present an algorithm for constructing a worst-case ROBDD of a given number of variables. Our approach may be useful to projects deciding whether the ROBDD is the appropriate data structure to use, and in building worst-case examples to test their code.

2018

• Proceedings of the Meta'18: Workshop on Meta-Programming Techniques and Reflection
• Article: PDF, HTML
• Reference: BibTeX
• We summarize a technique for writing functions which recognize types of heterogeneous sequences in Common Lisp. The technique employs sequence recognition functions, generated at compile time, and evaluated at run-time. The technique we demonstrate extends the Common Lisp type system, exploiting the theory of rational languages, Binary Decision Diagrams, and the Turing complete macro facility of Common Lisp. The resulting system uses meta-programming to move an exponential complexity operation from run-time to a compile-time operation, leaving a highly optimized linear complexity operation for run-time.

• The Art, Science and Engineering of Programming Journal
• Article: PDF, HTML
• Reference: BibTeX
• Live recording
• Interview (French)
• The relation between Science (what we can explain) and Art (what we can't) has long been acknowledged and while every science contains an artistic part, every art form also needs a bit of science. Among all scientific disciplines, programming holds a special place for two reasons. First, the artistic part is not only undeniable but also essential. Second, and much like in a purely artistic discipline, the act of programming is driven partly by the notion of aesthetics: the pleasure we have in creating beautiful things.

  Even though the importance of aesthetics in the act of programming is now unquestioned, more could still be written on the subject. The field called "psychology of programming" focuses on the cognitive aspects of the activity, with the goal of improving the productivity of programmers. While many scientists have emphasized their concern for aesthetics and the impact it has on their activity, few computer scientists have actually written about their thought process while programming.

  What makes us like or dislike such or such language or paradigm? Why do we shape our programs the way we do? By answering these questions from the angle of aesthetics, we may be able to shed some new light on the art of programming. Starting from the assumption that aesthetics is an inherently transversal dimension, it should be possible for every programmer to find the same aesthetic driving force in every creative activity they undertake, not just programming, and in doing so, get deeper insight on why and how they do things the way they do.

  On the other hand, because our aesthetic sensitivities are so personal, all we can really do is relate our own experiences and share it with others, in the hope that it will inspire them to do the same. My personal life has been revolving around three major creative activities, of equal importance: programming in Lisp, playing Jazz music, and practicing Aikido. But why so many of them, why so different ones, and why these specifically?

  By introspecting my personal aesthetic sensitivities, I eventually realized that my tastes in the scientific, artistic, and physical domains are all motivated by the same driving forces, hence unifying Lisp, Jazz, and Aikido as three expressions of a single essence, not so different after all. Lisp, Jazz, and Aikido are governed by a limited set of rules which remain simple and unobtrusive. Conforming to them is a pleasure. Because Lisp, Jazz, and Aikido are inherently introspective disciplines, they also invite you to transgress the rules in order to find your own. Breaking the rules is fun. Finally, if Lisp, Jazz, and Aikido unify so many paradigms, styles, or techniques, it is not by mere accumulation but because they live at the meta-level and let you reconstruct them. Working at the meta-level is an enlightening experience.

  Understand your aesthetic sensitivities and you may gain considerable insight on your own psychology of programming. Mine is perhaps common to most lispers. Perhaps also common to other programming communities, but that, is for the reader to decide...

• ELS 2018
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• In traditional object-oriented languages, the dynamic dispatch algorithm is hardwired: for every polymorphic call, only the most specific method is used. CLOS, the Common Lisp Object System, goes beyond the traditional approach by providing an abstraction known as "method combinations": when several methods are applicable, it is possible to select several of them, decide in which order they will be called and how to combine their results, essentially making the dynamic dispatch algorithm user-programmable.

  Although a powerful abstraction, method combinations are under-specified in the Common Lisp standard, and the MOP, the Meta-Object Protocol underlying many implementations of CLOS, worsens the situation by either contradicting it or providing unclear protocols. As a consequence, too much freedom is granted to conforming implementations, the exact or intended behavior of method combinations is unclear and not necessarily coherent with the rest of CLOS.

  In this paper, we provide a detailed analysis of the problems posed by method combinations, the consequences of their lack of proper specification in one particular implementation, and a MOP-based extension called "method combinators", aiming at correcting these problems and possibly offer new functionality.

• ELS 2018
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• We contrast two approaches to optimizing the Common Lisp typecase macro expansion. The first approach is based on heuristics intended to estimate run time performance of certain type checks involving Common Lisp type specifiers. The technique may, depending on code size, exhaustively search the space of permutations of the type checks, intent on finding the optimal order. With the second technique, we represent a typecase form as a type specifier, encapsulating the side-effecting non-Boolean parts so as to appear compatible with the Common Lisp type algebra operators. The encapsulated expressions are specially handled so that the Common Lisp type algebra functions preserve them, and we can unwrap them after a process of Boolean reduction into efficient Common Lisp code, maintaining the appropriate side effects but eliminating unnecessary type checks. Both approaches allow us to identify unreachable code, test for exhaustiveness of the clauses and eliminate type checks which are calculated to be redundant.

2017

• ELS 2017
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• In this article we contrast the use of the s-expression with the BDD (Binary Decision Diagram) as a data structure for programmatically manipulating Common Lisp type specifiers. The s-expression is the de facto standard surface syntax and also programmatic representation of the type specifier, but the BDD data structure offers advantages: most notably, type equivalence checks using s-expressions can be computationally intensive, whereas the type equivalence check using BDDs is a check for object identity. As an implementation and performance experiment, we define the notion of maximal disjoint type decomposition, and discuss implementations of algorithms to compute it: a brute force iteration, and as a tree reduction. The experimental implementations represent type specifiers by both aforementioned data structures, and we compare the performance observed in each approach.

2016

• ELS 2016
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Live recording
• We introduce the abstract concept of rational type expression and show its relationship to rational language theory. We further present a concrete syntax, regular type expression, and a Common Lisp implementation thereof which allows the programmer to declaratively express the types of heterogeneous sequences in a way which is natural in the Common Lisp language. The implementation uses techniques well known and well founded in rational language theory, in particular the use of the Brzozowski derivative and deterministic automata to reach a solution which can match a sequence in linear time. We illustrate the concept with several motivating examples, and finally explain many details of its implementation.

2015

• COP 2015
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Genericity aims at providing a very high level of abstraction in order, for instance, to separate the general shape of an algorithm from specific implementation details. Reaching a high level of genericity through regular object-oriented techniques has two major drawbacks, however: code cluttering (e.g. class / method proliferation) and performance degradation (e.g. dynamic dispatch). In this paper, we explore a potential use for the Context-Oriented programming paradigm in order to maintain a high level of genericity in an experimental image processing library, without sacrificing either the performance or the original object-oriented design of the application.

2013

• TUG 2013
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• In this article, I relate on a recent experience of mine: writing a book chapter for a publisher who doesn't have a clue about typesetting. I confess my futile attempt at using TeX for writing the chapter in question. I describe the hell that descended upon me for daring to do that. I however admit that the hell in question would have been even greater, hadn't I done so. This article is both a nervous breakdown and a laughter, and I am seeking for the reader's comfort.

• TUG 2013
• Article: PDF, HTML
• Transparents: PDF, HTML
• Code correspondant
• Reference: BibTeX
• At TUG 2012, we presented some ideas about using one of the oldest programming languages (Lisp), in order to modernize one of the oldest typesetting systems (TeX). This talk was mostly focused on justifying the technical fitness of Lisp for this task. This time, we would like to take the opposite view and demonstrate a prototype, from the user's perspective. This involves showing what a TiCL document could look like, the implications in terms of typesetting vs. programmatic features, and also in terms of extensibility (relate this to class / style authoring).

2012

• Common Document Repository #11
• Article: PDF, HTML
• Reference: BibTeX
• The Common Lisp standard mandates the existence of several streams such as *standard-output*, *erroroutput* and *@query-io*. The purpose of these streams, however, is only informally described, leading to implementation-specific behavior. This can be problematic for Lisp sessions started from a terminal (without a graphical user interface) and standalone command-line executables. As illustrated in the next section, the current behavior of some standard output streams, notably with respect to shell redirection may not only be different across implementations, but also contrary to the user's expectations. The purpose of this document is hence to illustrate the problem and suggest that all Common Lisp implementations agree on one particular scheme (one actually already adopted by two of them).

• Chapter 1 of: Formal and Practical Aspects of Domain Specific Languages: Recent Developments
• Reference: BibTeX
• Out of a concern for focus and concision, domain-specific languages (DSLs) are usually very different from general purpose programming languages (GPLs), both at the syntactic and the semantic levels. One approach to DSL implementation is to write a full language infrastructure, including parser, interpreter or even compiler. Another approach however, is to ground the DSL into an extensible GPL, giving you control over its own syntax and semantics. The DSL may then be designed merely as an extension to the original GPL, and its implementation may boil down to expressing only the differences with it. The task of DSL implementation is hence considerably eased. The purpose of this chapter is to provide a tour of the features that make a GPL extensible, and to demonstrate how, in this context, the distinction between DSL and GPL can blur, sometimes to the point of complete disappearance.

• TUG 2012
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• While TeX is unanimously praised for its typesetting capabilities, it is also regularly blamed for its poor programmatic offerings. A macro-expansion system is indeed far from the best choice in terms of general-purpose programming. Several solutions have been proposed to modernize TeX on the programming side. All of them currently involve a heterogeneous approach in which TeX is mixed with a full-blown programming language. This paper advocates another, homogeneous approach in which TeX is first rewritten in a modern language, Common Lisp, which serves both at the core of the program and at the scripting level. All programmatic macros of TeX are hence rendered obsolete, as the underlying language itself can be used for user-level programming.

• ELS 2012
• Article: PDF, HTML
• Reference: BibTeX
• We present Climb, an experimental generic image processing library written in Common Lisp. Most image processing libraries are developed in static languages such as C or C++ (often for performance reasons). The motivation behind Climb is to provide an alternative view of the same domain, from the perspective of dynamic languages. More precisely, the main goal of Climb is to explore the dynamic way(s) of addressing the question of genericity, while applying the research to a concrete domain. Although still a prototype, Climb already features several levels of genericity and ships with a set of built-in algorithms as well as means to combine them.

• Technical Report #201201-TR
• Article: PDF, HTML
• Reference: BibTeX
• In a time where the differences between static and dynamic languages are starting to fade away, this report brings one more element to the "convergence" picture by showing that thanks to the novelties from the recent C++0x standard, it is relatively easy to implement a JavaScript layer on top of C++. By that, we not only mean to implement the language features, but also to preserve as much of its original notation as possible. In doing so, we provide the programmer with a means to freely incorporate highly dynamic JavaScript-like code into a regular C++ program.

2011

• Onward!'11
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• In biology, evolution is usually seen as a tinkering process, different from what an engineer does when he plans the development of his systems. Recently, studies have shown that even in biology, there is a part of good engineering. As computer scientists, we have much more difficulty to admit that there is also a great deal of tinkering in what we do, and that our software systems behave more and more like biological realms every day. This essay relates my personal experience about this discovery.

• TUG 2011
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Live recording
• Because LaTeX is only a macro-expansion system, the language does not impose any kind of good software engineering practice, program structure or coding style. Maybe because in the LaTeX world, collaboration is not so widespread, the idea of some LaTeX Coding Standards is not so pressing as with other programming languages. Over the years, the permanent flow of personal development experiences contributed to shape our own taste in terms of coding style. In this paper, we report on all these experiences and describe what we think are good programming practices.

• Common Document Repository #9
• Article: PDF, HTML
• Reference: BibTeX
• The Common Lisp standard defines two special variables, *package* and *readtable*, that are treated in a special way: the functions load and compile-file establish a new dynamic binding for each of them, so that any modification to their value at load or compile time becomes local to the file being processed. The motivation for the present document is the claim that this behavior could be useful for other, user-defined variables, although there is currently no way to do so in standard Common Lisp.

• Common Document Repository #7
• Article: PDF, HTML
• Reference: BibTeX
• Section 22.3 "Formatted Output" of the Common Lisp Hyperspec describes the syntax and semantics of format directives. We believe that the standard is underspecified. We propose to clarify that section, and suggest that Common Lisp implementations conform to the current behavior of CMU-CL, CCL, CLISP, Allegro and LispWorks.

2010

• TUG 2010
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Live recording
• The LaTeX world is composed of thousands of software components, most notably classes and styles. Classes and styles are born, evolve or die, interact with each other, compete or cooperate, very much as living organisms do at the cellular level. This paper attempts to draw an extended analogy between the LaTeX biotope and cellular biology. By considering LaTeX documents as living organisms and styles as viruses that infect them, we are able to exhibit a set of behavioral patterns common to both worlds. We analyze infection methods, types and cures, and we show how LaTeX or cellular organisms are able to survive in a world of perpetual war.

• "I really enjoy Didier Verna's paper (pp. 162-172). His analogies between LaTeX and microbiology is truly exciting! Being neither a TeXnician nor a (micro) biologist, the paper gives me more insight about LaTeX while at the same time giving me a glimpse to a world beyond my narrow field of knowledge. Please do extend my compliments to the author."
  -- A TUGBoat reader.

• ELS 2010
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• CLoX is an ongoing attempt to provide a full Emacs Lisp implementation of the Common Lisp Object System, including its underlying meta-object protocol, for XEmacs. This paper describes the early development stages of this project. CLoX currently consists in a port of Closette to Emacs Lisp, with some additional features, most notably, a deeper integration between types and classes and a comprehensive test suite. All these aspects are described in the paper, and we also provide a feature comparison with an alternative project called Eieio.

• JUCS (Journal of Universal Computer Science)
• Reference: BibTeX
• While software design patterns are a generally useful concept, they are often (and mistakenly) seen as ready-made universal recipes for solving common problems. In a way, the danger is that programmers stop thinking about their actual problem, and start looking for pre-cooked solutions in some design pattern book instead. What people usually forget about design patterns is that the underlying programming language plays a major role in the exact shape such or such pattern will have on the surface. The purpose of this paper is twofold: we show why design pattern expression is intimately linked to the expressiveness of the programming language in use, and we also demonstrate how a blind application of them can in fact lead to very poorly designed code.

2009

• ILC 2009
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• This article reports the results of an ongoing experimental research on the behavior and performance of CLOS, the Common Lisp Object System. Our purpose is to evaluate the behavior and performance of the 3 most important characteristics of any dynamic object oriented system: class instantiation, slot access and dynamic dispatch. This paper describes the results of our experiments on instantiation. We evaluate the efficiency of the instantiation process in both C++ and Lisp under a combination of parameters such as slot types or classes hierarchy. We show that in a non-optimized configuration where safety is given priority on speed, the behavior of C++ and Lisp instantiation can be quite different, which is also the case amongst different Lisp compilers. On the other hand, we demonstrate that when compilation is tuned for speed, instantiation in Lisp can become faster than in C++.

2008

• JUCS (Journal of Universal Computer Science)
• Reference: BibTeX
• Implementing binary methods in traditional object-oriented languages is difficult: numerous problems arise regarding the relationship between types and classes in the context of inheritance, or the need for privileged access to the internal representation of objects. Most of these problems occur in the context of statically typed languages that lack multi-methods (polymorphism on multiple arguments). The purpose of this paper is twofold: first, we show why some of these problems are either non-issues, or easily solved in Common-Lisp. Then, we demonstrate how the Common-Lisp Object System (CLOS) allows us not only to implement binary methods in a straightforward way, but also to support the concept directly, and even enforce it at different levels (usage and implementation).

• ELS 2008
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Implementing binary methods in traditional object-oriented languages is difficult: numerous problems arise regarding the relationship between types and classes in the context of inheritance, or the need for privileged access to the internal representation of objects. Most of these problems occur in the context of statically typed languages that lack multi-methods (polymorphism on multiple arguments). The purpose of this paper is twofold: first, we show why some of these problems are either non-issues, or easily solved in Common-Lisp. Then, we demonstrate how the Common-Lisp Object System (CLOS) allows us not only to implement binary methods in a straightforward way, but also to support the concept directly, and even enforce it at different levels (usage and implementation).

2007

• IMECS 07
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Implementing binary methods in traditional object oriented languages is difficult: numerous problems arise, such as typing (covariance vs. contra-variance of the arguments), polymorphism on multiple arguments (lack of multi-methods) etc. The purpose of this paper is to demonstrate how those problems are either solved, or nonexistent in the Common Lisp Object System (CLOS). Several solutions for different levels of binary methods support in CLOS are proposed. They mainly consist in re-programming a binary method specific object system through the CLOS meta-object protocol.

2006

• PracTeX Journal
• Article: PDF, HTML
• Reference: BibTeX
• This paper presents CurVe, a curriculum vitae class for LaTeX2e, in a progressive approach going from a first contact with the class, through concrete examples of customization, and some aspects of advanced usage.

• ELW 06
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• This paper presents an ongoing research on the behavior and performance of LISP with respect to C in the context of scientific numerical computing. Several simple image processing algorithms are used to evaluate the performance of pixel access and arithmetic operations in both languages. We demonstrate that the behavior of equivalent LISP and C code is similar with respect to the choice of data structures and types, and also to external parameters such as hardware optimization. We further demonstrate that properly typed and optimized LISP code runs as fast as the equivalent C code, or even faster in some cases.

• Best paper award

• International Journal on Computer Science
• Contrary to popular belief, Lisp code can be very efficient today: it can run as fast as equivalent C code or even faster in some cases. In this paper, we explain how to tune Lisp code for performance by introducing the proper type declarations, using the appropriate data structures and compiler information. We also explain how efficiency is achieved by the compilers. These techniques are applied to simple image processing algorithms in order to demonstrate the announced performance on pixel access and arithmetic operations in both languages.

• IMECS 06
• Article: PDF, HTML
• Transparents: PDF, HTML
• Reference: BibTeX
• Contrary to popular belief, Lisp code can be very efficient today: it can run as fast as equivalent C code or even faster in some cases. In this paper, we explain how to tune Lisp code for performance by introducing the proper type declarations, using the appropriate data structures and compiler information. We also explain how efficiency is achieved by the compilers. These techniques are applied to simple image processing algorithms in order to demonstrate the announced performance on pixel access and arithmetic operations in both languages.

• Best paper award

2003

• TUGBoat
• Article: PDF, HTML
• Reference: BibTeX
• This paper relates the history of the development of Curve, a LaTeX2e class package for typesetting curricula vitae, and describes its specificities as well as the main aspects of it use.

2001

• SCI 01
• Article: PDF, HTML
• Reference: BibTeX
• This paper proposes an overview of a study that conceptually unify the fields of virtual reality and tele-operation, by analyzing the notion of "assistance" to the operator of a virtual reality or tele-operation system. This analysis demonstrates that cases of assistance that are usually considered to belong to virtual reality are not conceptually different from what has been done in tele-operation since long before virtual reality appeared. With this common framework for virtual reality and tele-operation, we hope to provide a theoretical formalization of many ideas acquired empirically, and hence a basis onto which further discussion could be undertaken in a constructive manner.

2000

• VSMM 00
• Article: PDF, HTML
• Reference: BibTeX
• This paper describes a research that has been conducted in the field of cognitive assistance to human-machine interaction in virtual environments. The idea is to design a system which, bearing in mind the actions performed by the operator at present and the current state of the environment, attempts to determine the global operation that the user is in the process of executing, and eventually takes control of the same process in order to complete it automatically. This idea implies the conception of an action recognition mechanism based on a specific knowledge representation model. This mechanism is implemented in a computer demonstrator, known as the ToASt system, which is also presented.

• VSMM 00
• Article: PDF, HTML
• Reference: BibTeX
• This paper describes Urbi et Orbi, a distributed virtual environment (DVE) project that is being conducted in the Research and Development Laboratory at Epita. Our ultimate goal is to provide support for large scale multi-user virtual worlds on end-user machines. The incremental development of this project led us to take unusual design and implementation decisions that we propose to relate in this paper. Firstly, a general overview of the project is given, along with the initial requirements we wanted to meet. Then, we go on with a description of the system's architecture. Lastly, we describe and justify the unusual choices we have made in the project's internals.

• Thèse de Doctorat
• Article: PDF, HTML
• Reference: BibTeX
• Ce travail traite de la notion d'assistance cognitive à l'Interaction Homme-Machine dans les environnements virtuels, and met en évidence les avantages d'une approche telle que la détection d'intentions comme source possible d'assistance intelligente. Le travail est organisé en trois grandes parties: l'élaboration d'un point de vue cognitif sur la notion de réalité virtuelle, une étude théorique sur la notion d'assistance dans les systèmes de réalité virtuelle, et une approche fondée sur la détection d'intentions.

1999

• EGVE 99
• Reference: BibTeX
• This paper aims at showing that the notion of augmented reality has been developed in a biased way: mostly in destination to the operator, and at the level of his perceptions. This demonstration is achieved through a model describing a situation of tele-operation, on which we represent major cases of augmented reality encountered in recent applications. By taking advantage of the symmetry of the model, we are able to show how augmented reality can be seen "the other way around", that is, in destination to the environment, and at the level of the operator's actions.

• ReViCo 99
• Article: PDF, HTML
• Reference: BibTeX
• Cet article décrit l'élaboration théorique d'une caractérisation cognitive du virtuel. Plutôt que de définir le virtuel en tant que tel, nous montrons qu'il est plus intéressant de définir les processus de virtualisation, c'est à dire les mécanismes cognitifs qui font qu'à partir d'une situation réelle, l'humain entre progressivement dans le virtuel. Dans un premier temps, un modèle cognitif décrivant l'interaction entre un humain et son environnement est proposé, le modèle MrIC. Les processus de virtualisation sont ensuite définis et nous permettent d'obtenir un certain nombre de variantes de ce modèle, décrivant les grandes catégories de situations virtualisées: situations de type CAO (avec nv), situations dites «immersives» (avec représentation virtuelle de l'humain) etc.

• M17N 99
• Article: PDF, HTML
• Reference: BibTeX
• This paper describes the recent multicast support that have been added to XEmacs, publicly available for the first time in XEmacs 21.0. First, a general overview of the "multicast" technology is given. Then, the internal support within XEmacs is described and the first multicast package for XEmacs is presented. The current problems and perspectives with this support are finally detailed.

• M17N 99
• Article: PDF, HTML
• Reference: BibTeX
• This paper presents some ergonomics and Human Machine Interaction problems that several input methods (notably the French ones) introduce in all Emacs flavors. First, a general overview of the available input methods is given. Then, some ergonomics problems are described. Finally, some ideas are proposed to improve the quality of these input methods.

1998

• VW 98
• Reference: BibTeX
• In this paper, we propose a reasoning model aimed at helping to decide on the virtual status of a given situation, from a human point of view rather than from a technological one. We first describe how a human and his environment interact. The notion of "reality" will be seen through this description. Then, we propose a set of possible "cognitive deviations" of reality leading to situations of virtual reality. This model provides three major benefits to the field of virtual reality: first, a global definition and a systematic mean of categorizing related situations; secondly, the ability to discuss on the virtual status of real situations and not only synthetic, computer generated ones; thirdly, a demonstration on how the field of tele-operation is heavily related to virtual reality concepts, and some perspectives on future tele-operation intelligent user interfaces.

• GTRV 98
• Reference: BibTeX
• Dans cette communication, nous nous proposons d'examiner les caractères de sémantique et de localisation de la notion d'assistance dans un contexte de réalité virtuelle. Pour cela, nous modélisons les composantes impliquées dans une situation où l'utilisateur interagit avec un environnement au travers d'un système artificiel. Ensuite, nous localisons sur le modèle un certain nombre de cas d'assistance courament rencontrés. L'organisation à la fois sémantique et géographique de ces cas d'assistance sur le modèle nous permet de les extrapoler à de nouveaux cas d'assistance moins évidents, et de montrer comment ces nouveaux exemples, particulièrement utiles en télé-opération, sont encore étroitement reliés à la notion de réalité virtuelle.

1997

• Rapport Technique
• Reference: BibTeX
• Le but de ce document est de fournir une réflexion approfondie sur la notion de réalité virtuelle. La démarche proposée consiste en l'élaboration d'un modèle représentant l'humain en interaction avec son environnement. C'est au travers de ce modèle qu'est perçue la notion de «réalité». Le concept de «réalité virtuelle» sera ensuite examiné en termes d'écart par rapport à une situation réelle. Cette démarche nous permet de préciser certains termes communément employés par la communauté scientifique, ainsi que de nous positionner par rapport aux définitions existantes.

• IHM 97
• Reference: BibTeX
• Notre travail se situe dans un contexte de télé-opération en monde virtuel. Nous appelons «monde virtuel» une situation, réelle ou simulée, dans laquelle les informations d'action et de perception sont transmises par des moyens artificiels. Un opérateur interagit donc avec un environnement qui n'est pas son environnement «direct». Dans une telle situation, notre approche consiste à étudier l'amélioration de la communication homme-machine en termes d'intelligence. Nous examinons la possibilité d'une communication se situant au niveau des intentions de l'opérateur: le système analyse la situation pour en déduire les intentions possibles de l'opérateur. Une fois l'intention détectée, le système propose une assistance totale ou partielle pour l'exécution de l'action correspondante.

1996

• GTRV 96
• Reference: BibTeX