Publications

Articles et communications scientifiques autour de Lisaac et de son écosystème.

2025/2026 (Working progress)

• Managing Multiple Precision Integer Data on Modern 64-Bit Architectures

  The 64-bit architectures that have become standard today offer unprecedented low-level programming possibilities. For the first time in the history of computing, the size of address registers far exceeded the physical capacity of their bus. After a brief reminder of the possibilities offered by the small size of addresses compared to the available 64 bits, we develop a concrete example of how the vacant bits of these registers can be used. Among these examples, two of them concern the implementation of a library for a new statically typed programming language. Firstly, the implementation of multi-precision integers, with the aim of improving performance in terms of both calculation speed and RAM savings.

04/2025

• Omega: The Power of Visual Simplicity

  We are currently developing an innovative and visually-driven programming language called Omega. Although the Omega code is stored in text files, these files are not intended for manual editing or traditional printing. Furthermore, parsing these files using a context-free grammar is not possible. The parsing of the code and the facilitation of user-friendly manual editing both necessitate a global knowledge of the codebase. Strictly speaking, code visualization is not an integral part of the Omega language; instead, this task is delegated to the editing tools. Thanks to the global knowledge of the code, the editing process becomes remarkably straightforward, with numerous automatic completion features that enhance usability. Omega leverages a visual-oriented approach to encompass all fundamental aspects of software engineering. It offers robust features, including safe static typing, design by contracts, rules for accessing slots, operator definitions, and more, all presented in an intuitively and visually comprehensible manner, eliminating the need for obscure syntax.

2024

• RIP Linked List Empirical Study to Discourage You from Using Linked Lists Any Further

  Linked lists have long served as a valuable teaching tool in programming. However, the question arises: Are they truly practical for everyday program use? In most cases, it appears that array-based data structures offer distinct advantages, particularly in terms of memory efficiency and, more importantly, execution speed. While it's relatively straightforward to calculate the complexity of operations, gauging actual execution efficiency remains a challenge. This paper addresses this question by introducing a new benchmark. Our study compares various linked list implementations with several array-based alternatives. We also demonstrate the ease of incorporating memory caching for linked lists, enhancing their performance. Additionally, we introduce a new array-based data structure designed to excel in a wide range of operations.

2014

• Exploiting array manipulation habits to optimize garbage collection and type flow analysis

  A widespread practice to implement a flexible array is to consider the storage area into two parts: the used area which is already available for read/write operations and, the supply area, which is used in case of enlargement of the array. The main purpose of the supply area is to avoid as much as possible the reallocation of the whole storage area in case of enlargement. We also present a simple method to analyze the types of objects which are stored in an array as well as the possible presence of null values within the array. This allows us to better specialize the work of the garbage collector when marking the used area, and also, by transitivity, to improve overall results for type analysis of all expressions of the source code. After introducing several abstract data types which represent the main arrays concerned by our technique (i.e. zero or variable indexing, circular arrays and hash maps), we measure its impact during the bootstrap of two compilers whose libraries are equipped with these abstract data types. We then measure, on various software products we have not written, the frequency of certain habits of manipulation of arrays, to assess the validity of our approach.

2013

• Efficient compilation strategy for object-oriented languages under the closed-world assumption

  Reaching the best level of runtime performance from a high-level, object-oriented language is often considered challenging if not unattainable. The closed world assumption involves considering all of the source code of an application together at compile-time. That assumption makes it possible to produce an efficient code. For instance, multiple inheritance can be implemented as efficiently as single inheritance. Our compilation strategy is the result of a prolonged project, tying together several compilation techniques: call graph analysis, dead code elimination, type flow analysis, code customization, implementation of dynamic dispatch, inlining, pointer optimization, switch optimization, objects layout, etc. Throughout the paper two real-world compilers are used as benchmarks to provide measurements for compiler-writers in order to evaluate the applicability of our approach. Type flow analysis is a fundamental aspect of our strategy to resolve method calls. We have extended type flow analysis to deal with the content of arrays, enabling us to process additional expressions and thus making it possible to obtain a true global analysis. Typically more than 90% of method call sites are statically resolved. Our experience indicates that the closed world assumption is suitable for numerous applications. Surprisingly, even library-defined control statements from dynamic languages are perfectly processed with our strategy. The Smalltalk ifTrue:ifFalse:, whileTrue:, to:do:, etc. are, for the very first time, perfectly translated.

2012

• Analyse simple de types dans les tableaux et optimisation du ramasse-miettes

  Cet article commence en présentant une technique très simple, par analyse de flots de types et ordre de remplissage imposé, permettant de prédire le contenu des tableaux. D'abord présentée pour les tableaux primitifs indexés à partir de 0, notre technique est ensuite étendue pour prendre en compte les autres structures de données de plus haut niveau: tableaux à indexation variable, tableaux circulaires et tables de hachage. Le résultat essentiel consiste à pouvoir faire suivre l'information de flots de types déjà collectée pour le reste du code source au travers des expressions qui manipulent des tableaux, permettant ainsi de procéder à une analyse de flots de types vraiment globale. En plus de l'amélioration de la prédiction de types utile pour la liaison dynamique et la sécurité des langages à objets, notre technique permet d'optimiser la gestion mémoire. En effet, grâce à la technique de remplissage utilisée, le ramasse-miettes (GC) n'inspecte que les zones utiles des tableaux en évitant de collecter des objets inaccessibles, référencés par les zones de réserve. Ces zones de réserve n'ont par ailleurs nullement besoin d'être initialisées avant utilisation ni nettoyées aprés usage. Les mesures présentées permettent de se rendre compte de l'impact de cette technique, aussi bien en terme de qualité de l'analyse de flots, qu'en terme de gain au niveau de la gestion mémoire durant le marquage et le balayage des tableaux.

04/2006

• Hardware Memory Segmentation for New Software Model

  This article is the conclusions of a study on the implementation of a new oriented object operating system. Nowadays, some processors offer advanced mechanisms of memory management through segmentation. Unfortunately, they are unusable in some contexts such as ANSI C programming. At first sight, the implementation of an operating system using such a mechanism would need prior rewriting of the stack in order to take account for memory allocation indexes. This article brings a simple and effective solution to allow processor segmentation. Moreover, this solution does not require any massive modification of the stack.

03/2006

• Lisaac Agent - Petit Modèle Agent pour Langage à Prototype

  Nous proposons dans cet article les bases d'un modèle simple de langage orienté agents réactifs pour le langage Lisaac, langage objet à prototype compilé. Nous présentons les axiomes de base à implémenter dans le compilateur afin d'intégrer des mécanismes agents, en s'adaptant aux spécificités d'un langage objet à prototype. Nous proposons l'intégration de mécanismes comme la gestion de messages multicast, la définition du comportement réactif de l'agent, un mécanisme de structuration de SMA, et un mécanisme d'extraction structuré de données.

03/2005

• Une Alternative Objet de Haut Niveau pour la Programmation Système

  Le marché fleurissant de l'informatique embarquée impose une réutilisabilité croissante du code existant tout en ayant de fortes contraintes matérielles. Il est nécessaire de s'adapter rapidement à un matériel hétéroclite. Nous défendons l'emploi de langages objets de haut niveau comme véritable alternative au C pour les systèmes d'exploitation et couches applicatives, en soulignant les bénéfices d'abstraction et d'évolutivité.

06/2002

• Dynamic inheritance: A Powerful Mechanism for Operating System Design

  The design of the Isaac operating system comes from several years of reflection and implementation on the need for flexibility and dynamism in future operating systems. Prototype-based languages appeared the most elegant manner to materialize our vision of operating system. These, coupled with a powerful language allowing changing inheritance dynamically, made it possible to create the innovating Isaac OS.

02/2002

• The Power of Simplicity at Work for Operating System

  The design as well as the implementation of the Isaac operating system led us to set up a new programming language named Lisaac. Many features from the Lisaac language come from the Self programming language. Lisaac integrates communications protection mechanisms and tools related to operating systems' design; system interruptions support and drivers memory mapping have been considered. Prototypes and dynamic inheritance fit a flexible operating system in the making. First compiled benchmarks show performance close to C.

04/2001

• Utilisation de la Segmentation Mémoire du Processeur à Partir d'un Langage de Haut Niveau

  Cet article est le fruit d'une étude sur la mise en place d'un nouveau système d'exploitation entièrement en objets. Nous dénonçons le manque de flexibilité de la gestion mémoire par l'absence d'utilisation de la segmentation. Nous proposons une solution simple et efficace pour permettre la prise en charge de la segmentation processeur en mémoire sans modification massive du compilateur.