Didier Verna

JSPP: Morphing C++ into JavaScript

Abstract

In a time where the differences between static and dynamic languages are starting to fade away, this paper 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.

Continue reading

Star TeX: The next generation

Abstract

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 is mixed with a full-blown programming language. This paper advocates another, homogeneous approach in which TeX is first rewritten in a modern language, , 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.

Continue reading

Biological realms in computer science: The way you don’t (want to) think about them

Abstract

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.

Continue reading

Towards LaTeX coding standards

Abstract

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.

Continue reading

Classes, styles, conflicts: The biological realm of LaTeX

Abstract

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.

Continue reading

CLoX: Common Lisp objects for XEmacs

Abstract

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.

Continue reading

Revisiting the visitor: The just do it pattern

Abstract

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.

Continue reading

Binary methods programming: The CLOS perspective

Abstract

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).

Continue reading

CLOS efficiency: instantiation

Abstract

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 becomes faster than in C++.

Continue reading

Revisiting the visitor: The just do it pattern

Abstract

Continue reading