Tuesday, January 31 2012
By Didier Verna on Tuesday, January 31 2012, 17:15 - Miscellaneous
Tuesday, July 19 2011
By Didier Verna on Tuesday, July 19 2011, 17:02 - LaTeX
EDIT: the paper is now freely available for non TUG members.
I'm happy to announce that my contribution to TUG 2011, the next TeX Users Group International conference, has been accepted. Please find the title and abstract below.
Towards LaTeX Coding Standards
Because LaTeX (and ultimately TeX) is only a macro-expansion system, the language does not impose any kind of good software engineering practice, program structure or coding style whatsoever. As a consequence, writing beautiful code (for some definition of "beautiful") requires a lot of self-discipline from the programmer.
Maybe because in the LaTeX world, collaboration is not so widespread (most packages are single-authored), the idea of some LaTeX Coding Standards is not so pressing as with other programming languages. Some people may, and probably have developed their own programming habits, but when it comes to the LaTeX world as a whole, the situation is close to anarchy.
Over the years, the permanent flow of personal development experiences contributed to shape my own taste in terms of coding style. The issues involved are numerous and their spectrum is very large: they range from simple code layout (formatting, indentation, naming schemes etc.), mid-level concerns such as modularity and encapsulation, to very high-level concerns like package interaction/conflict management and even some rules for proper social behavior.
In this talk, I will report on all these experiences and describe what I think are good (or at least better) programming practices. I believe that such practices do help in terms of code readability, maintainability and extensibility, all key factors in software evolution. They help me, perhaps they will help you too.
Monday, December 6 2010
By Didier Verna on Monday, December 6 2010, 09:20 - Lisp
I'm please to announce that I will be giving a talk at the next ACCU conference. The abstract is given below:
Meta-circularity... and vice-versa
As complexity increases, one often feels limited by the use of a single language, and incorporates new technology in order to express the original problem more abstractly, more precisely, and design solutions more efficiently. Using better-suited languages also has the advantage of letting you think about your problem in new and different ways, perhaps ways that you had not thought of before. It is thus no surprise to see the profusion of new languages that we face today, notably scripting and domain-specific ones.
But then, why the need for all this new and different technology? Wouldn't it be better if your primary language could evolve the way you want it to? And why is it not generally possible? Perhaps, because your primary language is not really extensible...
Meta-linguistic abstraction, that is, the art of language design plays a capital role in computer science because we have the ability to actually implement the languages we design, for instance by creating interperters for them. A fundamental idea in this context is that an interpreter is just another program (by extension, one could argue that any program is an interpreter for a particular language).
In this session, we will revive a historical moment in computer science: the birth of meta-circularity. When, in 1958, John McCarthy invented Lisp, he hadn't foreseen that given the core 7 operators of the language, it was possible to write Lisp in itself, by way of an interpreter. The practical implication of meta-circularity is that a meta-circular language gives you direct control over the semantics of the language itself, and as a consequence, means to modify or extend it. No wonder, then, why lispers never felt the need for external DSLs, scripting languages, XML or whatever. The reason is that Lisp, being extensible, can do all that by itself. Lisp is, by essence, the "programmable programming language".
Wednesday, December 1 2010
By Didier Verna on Wednesday, December 1 2010, 19:50 - LaTeX
Here's a nice comment from a reader of the TUGBoat on my TUG 2010 paper entitled "Classes, Styles, Conflicts: the Biological Realm of LaTeX":
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.
Tuesday, October 5 2010
By Didier Verna on Tuesday, October 5 2010, 12:14 - LaTeX
I'm pleased to announce that my article entitled "Classes, Styles, Conflicts: the Biological Realm of LaTeX" has been published in the TUGboat journal, Volume 32 N.2.
There is also a live video recording of the presentation. See http://www.lrde.epita.fr/~didier/resear ... rna.10.tug
Monday, May 10 2010
By Didier Verna on Monday, May 10 2010, 13:54 - Lisp
My paper entitled "CLoX: Common Lisp Objects for XEmacs", presented at the 3rd European Lisp Symposium last week, is now available for download on my website.
You can find it here
Wednesday, April 14 2010
By Didier Verna on Wednesday, April 14 2010, 17:06 - Lisp
My article entitled "Revisiting the Visitor: the Just Do It Pattern" has just been published in the JUCS journal, Volume 16, Issue 2.
You can find it here
Tuesday, March 9 2010
By Didier Verna on Tuesday, March 9 2010, 16:09 - Lisp
I'm happy to announce that I will be presenting a paper at ELS 2010, the next European Lisp Symposium, in Lisbon. The abstract is given below:
CloX: Common Lisp Objects for XEmacs
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.
By Didier Verna on Tuesday, March 9 2010, 08:36 - LaTeX
I'm happy to announce that I will be presenting a paper at TUG 2010, in San Francisco, for the 2^5th birthday of TeX. The abstract is given below:
Classes, Styles, Conflicts: the Biological Realm of LaTeX
Every LaTeX user faces the "compatibility nightmare" one day or another. With so much intercession capabilities at hand (LaTeX code being able to redefine itself at will), a time comes inevitably when the compilation of a document fails, due to a class/style conflict. In an ideal world, class/style conflicts should only be a concern for package maintainers, not end-users of LaTeX. Unfortunately, the world is real, not ideal, and end-user document compilation does break.
As both a class/style maintainer and a document author, I tried several times to come up with some general principles or a systematic approach to handling class/style cross-compatibility in a smooth and gentle manner, but I ultimately failed. Instead, one Monday morning, I woke up with this vision of the LaTeX biotope, an emergent phenomenon whose global behavior cannot be comprehended, because it is in fact the result of a myriad of "macro"-interactions between small entities, themselves in perpetual evolution.
In this presentation, I would like to draw bridges between LaTeX and biology, by viewing documents, classes and styles as living beings constantly mutating their geneTeX code in order to survive \renewcommand attacks...
Friday, April 24 2009
By Didier Verna on Friday, April 24 2009, 16:04 - Lisp
Now that my talk at ACCU 2009 is over, it's okay to post the material here. So I've just uploaded the slides in PDF, and the accompanying source code. You will find all that material here
. Be sure to start by opening the tarball and reading the README file. Then you can look at the source code and browse the slides in the same time.
Tuesday, March 31 2009
By Didier Verna on Tuesday, March 31 2009, 07:33 - Lisp
The Journal version of this paper of mine is finally available. This is an extended version of the paper I presented at the first European Lisp Symposium last year. It's about twice as long and contains much more details.
Although it's a journal article, the PDF is freely available
at the Journal's website.
Monday, March 30 2009
By Didier Verna on Monday, March 30 2009, 16:07 - Lisp
I've just uploaded the material regarding my paper at the International Lisp Conference 2009
. This includes the paper itself in PDF, a copy of the slides also in PDF, and the tarball of my benchmarking system.
I took the time to write a little bit of documentation about how to use it, so I hope this won't be too much of a pain to understand how it works.
ILC 2009 was great fun !
Tuesday, January 13 2009
By Didier Verna on Tuesday, January 13 2009, 16:11 - Lisp
I will hold a 90 minutes session at the next ACCU
conference, in the special track on patterns. Here is a description of my talk:Revisiting the Visitor: the "Just Do It" pattern.
A software design pattern is a three-part rule which expresses a relation between a certain context, a problem, and a solution. The well-known "GoF Book" describes 23 software design patterns. Its influence in the software engineering community has been dramatic. However, Peter Norvig notes that "16 of [these] 23 patterns are either invisible or simpler [...]" in Dylan or Lisp (Design Patterns in Dynamic Programming, Object World, 1996).
We claim that this is not a consequence of the notion of "pattern" itself, but rather of the way patterns are generally described; the GoF book being typical in this matter. Whereas patterns are supposed to be general and abstract, the GoF book is actually very much oriented towards mainstream object languages such as C++. As a result, most of its 23 "design patterns" are actually closer to "programming patterns", or "idioms", if you choose to adopt the terminology of the POSA Book.
In this talk, we would like to envision software design patterns from the point of view of dynamic languages and specifically from the angle of CLOS, the Common Lisp Object System. Taking the Visitor pattern as an illustration, we will show how a generally useful pattern can be blurred into the language, sometimes to the point of complete disappearance.
The lesson to be learned is that software design patterns should be used with care, and in particular, will never replace an in-depth knowledge of your preferred language (in our case, the mastering of first-class and generic functions, lexical closures and meta-object protocol). By using patterns blindly, your risk missing the obvious and most of the time simpler solution: the "Just Do It" pattern.
By Didier Verna on Tuesday, January 13 2009, 16:00 - Lisp
It is my pleasure to announce the acceptance of the following paper to the next International Lisp Conference
, to be held at MIT, Cambridge, March 2009.
CLOS Efficiency: Instantiation
-- on the behavior and performance of Lisp, part 2.1 --
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++.