European Lisp Symposium 2009 - programme details!

On May 27-29, there will be the 2nd European Lisp Symposium taking place in Milan, Italy. The program looks very exciting, and I will definitely be there (well, due to obvious reasons, see below ;).

For example, there are two keynote talks. One is by Kent Pitman who is an award-winning author of technical papers about Lisp, editor of the ANSI Common Lisp specification, and designer of the HyperSpec, the de-facto standard manual for Common Lisp. He will discuss how the Lisp community should move forward from his perspective. Kent's ideas are always well thought-out, although at times controversial, so this is certainly going to be a provocative talk.

The other is by João Pavão Martins and Ernesto Morgado, the two owners of SISCOG - a Portuguese company that develops large-scale industrial planning and scheduling software which is in use for over twenty years. It's always good to hear what practitioners have to tell about their experiences with Lisp, so this should turn out quite interesting.

There will be a couple of presentations in the main track of the symposium about papers that have been reviewed by a program committee chaired by António Leitão.

Jim Newton is going to present a type inferencing approach for the Skill dialect of Lisp that is actually being used in his group at Cadence Design Systems, one of the world-wide largest providers of Eletronic Design Automation. (If you use an eletronic device, it's very likely that the chips inside were designed using one of their tools!)

Thomas Burdick is going to present an approach for compiling FEXPRs (think: first-class macros that you can pass around like regular functions). I'm a bit skeptical here that this will work, because it is actually known that FEXPRs cannot be compiled, but maybe he has found an interesting twist to the problem.

Some colleagues of mine from the Artificial Intelligence Lab of the Vrije Universiteit Brussel in Belgium are going to present a debugging technique they have devolped for their own large-scale agent system that they use to investigate the possible development of natural languages by reconstructing how they could have evolved from simple, first-class principles. The debugging approach consists of monitoring the activities of the agents and presenting the process as an interactive webpage that can present arbitrary detailed (or abstract) views on what is happening. Very cool stuff here, and since they use web technology here, it is actually portable...

Charlotte Herzeel is going to present an architecture for Software Transactional Memory (STM). STM has become quite a hot topic in the last few years because it seems a very promising approach for dealing with concurrency, and since multicore processors are the buzz of the moment, there is a lot of interesting in such approaches. However, little attention has been payed to the design of STM frameworks where you can selectively plug in different STM algorithms. Charlotte has developed a reflective approach (think: metaobject protocol) for STM, which seems very promising (but I'm one of the co-authors of the paper, so I'm naturally biased, of course ;).

Another presentation will be about Linda-style distribution layer on top of Kenzo, an apparently very powerful system for symbolic computation developed in Common Lisp. The Linda Model (also used in JavaSpaces and TSpaces, for example) has a number of very interesting properties for distributed computing, and the paper presents an implementation based on AllegroCache, a robust and high-performance object-oriented database for Allegro Common Lisp. I'm wondering what the concrete benefits for a symbolic algebra system are, so this is another presentation to look forward to.

Finally, I am going to present a paper myself - that's the main reason why I will definitely be there ;). My presentation will be about a macro system on top of Common Lisp's macros that allows writing hygienic macros. The system provides facilities similar to Clinger's renaming construct. The interesting part is that my system is implemented in fully portable Common Lisp and integrated in such a way that 'regular' Common Lisp macros and the macros developed with this new macro system can be used together. The reason why this works is because of the use of symbol macros in the implementation of the new constructs.

Other items on the programme for the symposium are:

A debate on expanding and updating the Common Lisp standard. I am known to be quite conservative when it comes to this topic, in that I don't think ANSI Common Lisp needs a serious revision, but can be developed in a piecemeal fashion (and this actually already happens due to the efforts of the currently very vibrant Common Lisp community). I believe (obviously) that something like CDR is much more promising than a "big bang" revision of the core language. The recent developments in the Scheme community, where the highly controversial R6RS specification was almost not ratified, seems to indicate that the danger is too high that a lot of time and resources could be wasted that can otherwise be used in a much more productive way. Well, maybe there will be some new ideas and visions coming out of the debate...

On the Saturday after the symposium, there will be a visit to the Futurism exhibit in Milan. Futurism was an art movement in Italy in the early 20th century, whose founders announced that everything "old" (so artistic and political tradition) should be replaced by the new ideas of a then young generation. This is probably one of the strangest choices for the social programme of a Lisp-related event: Lisp is second oldest programming language still in use today, and has always been in competition with whatever other programming language came along that was considered to be 'newer' (as if that automically meant 'better'). However, judging for example from this blog posting, this could actually be a very inspiring exhibition.

So all in all, a highly interesting programme, with some more items being added in the coming days. (There are rumours that Christophe Rhodes is going to give a tutorial about non-portable features of SBCL, for example!) Although the early registration deadline is ending very soon now, there is no reason to despair: With €80 for students and €160 for regular participants, the registration fees will remain very low.

So, hope to see you in Milan!

Credo

It has been suggested that certain programming language constructs, in particular the GO TO, lend themselves to obscure coding practices. Some language designers have even gone so far as to design languages which purposely omit such familiar constructs as GO TO in an attempt to constrain the programmer to refrain from particular styles of programming thought by the language designer to be "bad" in some sense. But any language with function calls, functional values, conditionals, correct handling of tail-recursions, and lexical scoping can simulate such "non-structured" constructs as GO TO statements, call-by-name, and fluid variables in a straightforward manner. If the language also has a macro processor or preprocessor, these simulations will even be convenient to use.

No amount of language design can force a programmer to write clear programs. If the programmer's conception of the problem is badly organized, then his program will also be badly organized. The extent to which a programming language can help a programmer to organize his problem is precisely the extent to which it provides features appropriate to his problem domain. The emphasis should not be on eliminating "bad" language constructs, but on discovering or inventing helpful ones.

Guy L. Steele Jr. and Gerald J. Sussman
Lambda - The Ultimate Imperative

Lisp: Research and Experience

In the last couple of years, we have seen a growing interest in the Lisp programming language and its various dialects, including classic ones, like Common Lisp and Scheme, and also brand new ones, like Clojure and Qi. Several user group meetings, workshops and conferences have been organized with great success in recent years, especially in Europe, but also elsewhere.

With the European Lisp Symposium, we aim to start a series of annual events that is especially suitable for novel research results, but also for insights and lessons learned from practical applications and education perspectives, all involving Lisp dialects. The first symposium was organized in Bordeaux, France, on May 22 and 23, 2008.

For this symposium, we have received 15 submissions, and after a careful review process, the program committee selected seven of them for presentation at the main track of the symposium. The program committee considered six of these papers worthy of being invited for a journal publication. Their authors submitted extended versions of these papers, and after another thorough review process with additional reviewers, these papers have indeed reached the necessary level of quality and maturity.

These papers are now finally published in a special issue Lisp: Research and Experience of the Journal of Universal Computer Science.

Preparations for the 2nd European Lisp Symposium to be held in Milan, Italy, May 27-29, 2009 are already under way...

European Lisp Symposium 2009

There will be another instance of the European Lisp Symposium this year: in Milan, Italy, from May 27-29, 2009. It's very good that this event takes place so relatively shortly after the successful European Lisp Symposium 2008 about one year ago. Special kudos go to Marco Antoniotti for the local organization and Antonio Leitao for having assembled a great program committee.

The rates for attending the symposium are again very reasonable: Students can get in for as low as €60, and other participants for reasonable €100, when taking advantage of the early registration rates. See the registration page at the symposium website for more details.

More importantly, though: You can still submit papers to the symposium. The deadline for paper submissions is February 4, 2009, and the program committee accepts both original contributions, including research papers and experience reports, as well as descriptions of work in progress. Again, see the symposium website for more details.

Lisp50@OOPSLA

...celebrating the 50th birthday of Lisp at OOPSLA 2008

Monday, October 20, 2008
Nashville, Tennessee, USA
co-located with OOPSLA 2008
participation is free for all OOPSLA participants
registration for at least one conference day at OOPSLA is required

URL: http:www.lisp50.org
Feed: http://lisp50.blogspot.com


Invited Speakers

• William Clinger, Northeastern University, USA


• Pascal Costanza, Vrije Universiteit Brussel, Belgium


• Richard Gabriel, IBM Research, USA


• Rich Hickey, Independent Consultant, USA


• Alan Kay, Viewpoints Research Institute, USA


• Fritz Kunze, USA


• Ora Lassila, Nokia Research Center, USA


• John McCarthy, USA


• Kent Pitman, PTC, USA


• Guy Steele, Sun Microsystems Laboratories, USA


• Herbert Stoyan, University of Erlangen, Germany


• Warren Teitelman, Google Inc., USA


• JonL White, USA

Titles, abstracts, biographies and schedule will be announced at the
Lisp50 webpage and blog in the coming days and weeks.


Abstract

In October 1958, John McCarthy published one in a series of reports about his then ongoing effort for designing a new programming language that would be especially suited for achieving artificial intelligence. That report was the first one to use the name LISP for this new programming language. 50 years later, Lisp is still in use. This year we are celebrating Lisp's 50th birthday. OOPSLA 2008 is an excellent venue for such a celebration, because object-oriented programming benefited heavily from Lisp ideas and because OOPSLA 2008 takes place in October, exactly 50 years after the name Lisp has been used publicly for the first time. We will have talks by John McCarthy himself, and numerous other influential Lispers from the past five decades. We will also take a look at the next 50 years of Lisp.


Organizers

• Pascal Costanza, Vrije Universiteit Brussel, Belgium


• Richard Gabriel, IBM Research, Hawthorne, NY, USA


• Robert Hirschfeld, Hasso-Plattner-Institut, Potsdam, Germany


• Guy Steele, Sun Microsystems Laboratories, Burlington, MA, USA

Sponsored by ACM SIGPLAN


Supported by

• IBM Research


• LispWorks Ltd


• Franz Inc.


• Clozure Associates

Reflection for the Masses

Programming languages provide more or less narrow models on how solutions should be represented and thought about, and enforce such models in more or less strict ways. However, it always happens that the offered models are not completely appropriate, but need to be adapted in some ways to better fit a concrete problem at hand. Design patterns and programming styles provide ways to deal with such situations: By applying some principles in your code, you can work around limitations of a programming language and/or benefit from properties that arise from such principles. For example, it is then possible to replace algorithms at runtime in an otherwise static language, take advantage of a "pure" functions in an otherwise imperative language, and so on.

Reflection is a more systematic way to open up a programming language and extend it beyond the designer's original intent. By exposing internal implementation details of the language to programmers, they can add and modify features of the language in a principled way. For example, metaobject protocols are prime examples of reflection in programming languages.

Reflection is one of the corner stones of programming languages: Many programming languages provide some form of reflection, and certainly almost all of the widely used ones. So there seem to be clear benefits from being able to inspect and extend languages from within themselves.

The first dedicated account of reflection was provided by Brian C. Smith at the beginning of the 1980's, and he used his own dialect called 3-Lisp as a way to illustrate the principles behind reflection, especially for procedural, but also for structural reflection. (Instead of "procedural reflection," we would nowadays say "behavioral reflection.") Unfortunately, Smith's papers and PhD thesis are very hard to follow and understand: Since he is primarily a philosopher, and not a computer scientist, he uses terminology borrowed from philosophy, and on top of that, takes concepts from Lisp dialects of his time for granted that even seasoned modern Lispers do not fully grasp anymore.

In a recent attempt to better understand the ideas and concepts behind Smith's account of reflection and 3-Lisp, Charlotte Herzeel and myself carefully studied Smith's papers and the follow-up literature that directly referred to Smith's work in detail. Eventually, Charlotte reimplemented 3-Lisp in Common Lisp, and we discussed several aspects of that implementation from various perspectives. In the end, we were both surprised how well thought out Smith's conceptualization is even with regard to lots of details you have to face when actually implementing reflection - details that many of the follow-up authors in their own accounts seemed to have missed. However, we are also convinced that Smith made some "mistakes" - especially, we are now convinced that the model of an "infinite reflective tower" is at best a neat theoretical setup, but not at all useful for practical purposes.

Our work culminated in a paper called "Reflection for the Masses," co-authored with Theo D'Hondt, which Charlotte presented at this year's Workshop on Self-sustaining Systems (S3) in Potsdam, Germany. The paper is now also available on my website. It discusses Charlotte's implementation of 3-Lisp in detail and explains the concepts and details of reflection as we see them. It also contains the full implementation of 3-Lisp in Common Lisp as an appendix.

We are very proud of that paper. We think that we achieved a major step forward in better explaining reflection to a more general audience. It is still a presentation that is probably a lot easier to understand for Lispers, and probably quite hard to follow for non-Lispers, but we removed a lot of Smith's obscurities in his original presentation and are convinced that especially Common Lispers should be able to easily understand and enjoy our version.

New versions of Closer libraries released

I have just released new versions of all Closer libraries, including Closer to MOP and ContextL.

A major change that affects all libraries is that I have dropped support for Macintosh Common Lisp, and "replaced" OpenMCL with Clozure Common Lisp. Furthermore, the dependency of Closer to MOP to LW-Compat has been removed due to requests by users, but a dependency of ContextL to the portable-threads librarie of the GBBopen project has been added.

Other highlights include:

Closer to MOP 0.5

• In MCL, OpenMCL and Clozure Common Lisp, funcallable-standard-object is now exported from Closer to MOP.


• Fixed the lack of :generic-function-argument-precedence-order-returns-required-arguments in Allegro Common Lisp.


• Ensured that a defgeneric form makes a generic function metaobject available in the compile-time environment. Otherwise, defmethod may not yield a method of the correct method metaobject class.


• Added support for compute-discriminating-function in Clozure Common Lisp and OpenMCL, based on code provided by Slava Akhmechet.


• Added a classp predicate (due to Willem Broekema).

ContextL 0.5

• Added :in as an alternative for :in-layer in the various define-layered-xyz macros.


• ContextL now depends on portable-threads of the GBBopen project. This is done for locking critical sections to ensure thread safety of ContextL.


• Added new functions active-layers and (setf current-layer-context).


• Added a garbage collector for layer caches, such that redefinition of layers or certain methods in the ContextL MOP have an effect.


• Simplified mapping of layer-related names to internal names, which should also make things easier to read when debugging ContextL programs.

MOP Feature Tests 0.45

• Added new recognized standard feature :generic-function-argument-precedence-order-returns-required-arguments.


• Added a new known extra feature for SBCL (since SBCL version 1.0.14).

The libraries can be downloaded from the Closer Project and are asdf-installable, as usual.

Reengineering Patterns

Most people misunderstand the concept of patterns. This is probably mostly due to the Design Patterns book by Gamma, Helm, Johnson and Vlissides, which only conveys parts of what patterns can actually express and what they can be used for. People who know "better" languages know that most of the design patterns in that book can be much easier expressed, such that they virtually go away. However, that's not the "fault" of the patterns concept, that's rather a problem with that book, in that quite boring patterns have been selected.

A much better book is "Object-Oriented Reengineering Patterns" by Demeyer, Ducasse and Nierstrasz. In my opinion, it is probably the best book about (software-related) patterns that has been published so far. The good news is that the book is now freely available for download, so check it out.