Here is an interesting selection of recent publications.

2012

Extensible Languages: Blurring the Distinction between DSLs and GPLs

Verna, D. (2012). In Marjan Mernik editor, Formal and Practical Aspects of Domain Specific Languages: Recent Developments, Chapter 1, IGI Global.

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

Star TeX: the Next Generation

Verna, D. (2012). In TUGboat 33:2 2012, Proceedings of TUG 2012, the TeX Users Group conference.

• verna.12.tug.pdf
• Slides
• 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.

Generic Image Processing with Climb

Senta, L., and Chedeau, C., and Verna, D. (2012). In Proceedings of the 5rd European Lisp Symposium.

• Paper
• 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.

JSPP: Morphing C++ into JavaScript

Chedeau C., Verna, D. (2012). Technical Report #201201-TR

• Report
• 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

Biological Realms in Computer Science

Verna, D. (2011). In Onward!'11: the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software Proceedings

• Paper
• Slides
• ACM Digital Library
• 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.

Towards LaTeX Coding Standards

Verna, D. (2011). In TUGboat 32:3 2011, Proceedings of TUG 2011, the TeX Users Group conference.

• Paper
• Slides
• Tug 2011 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.

File-Local Variables

Verna, D. (2011). In CDR 9, Common Document Repository #9.

• Paper
• 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.

Clarification Proposal for CLHS 22.3

Verna, D. (2011). In CDR 7, Common Document Repository #7.

• Paper
• 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

Classes, Styles, Conflicts: the Biological Realm of LaTeX

Verna, D. (2010). In TUGboat 31:2 2010, Proceedings of TUG 2010, the TeX Users Group conference.

• Paper
• Slides
• Tug 2010 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.
• "Got your paper, read it, enjoyed it thoroughly. You write elegantly, concisely and eloquently."
  -- David West

CLoX: Common Lisp Objects for XEmacs

Verna, D. (2010). In Proceedings of the 3rd European Lisp Symposium.

• Paper
• Slides
• 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.

Revisiting the Visitor: the Just Do It Pattern

Verna, D. (2010). In Journal of Universal Computer Science, Volume 16, Issue 2, Pages 246 -- 271.

• Paper
• Lisp Code
• 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

CLOS Efficiency: Instantiation -- On the Behavior and Performance of Lisp, Part 2.1

Verna, D. (2009). In Proceedings of the International Lisp Conference , MIT, Cambridge, Massachusetts, USA.

• Paper
• Slides
• Benchmarks
• 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

Binary Methods Programming: the CLOS Perspective.

Verna, D. (2008). In Journal of Universal Computer Science, Volume 14, Issue 20, Pages 3389 - 3411.

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

2006

Verna, D. (2006). In The PracTeX Journal, number 3, August 2006.

• Paper
• 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.

Beating C in Scientific Computing Applications -- On the Behavior and Performance of Lisp, Part I.

Verna, D. (2006). In Third European LISP Workshop at ECOOP , Nantes, France.

• Best paper award winner
• Paper
• Slides
• 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.

2003

Verna D. (2003). In TugBoat, volume 22, number 4, December 2001, pages 361 -- 364.

• Paper
• 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.