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.

ELS'08 Report

Last week, the 1st European Lisp Symposium took place in Bordeaux, France. It was a very successful event, with some excellent paper presentations, but also more interactive formats. For example, we tried out the writers' workshop format for what we called a "work-in-progress" track, which was pretty well received by the participating authors. It's a format that focuses on improving the quality of papers that are not yet ready for publication. I'm very optimistic that we will see the results of this track at future Lisp events. We also organized "birds of a feather" sessions on various topics (distributed programming, image processing, CLIM and better system definition facilities), which were also very well received by the participants. It is my hope that future Lisp events will have more of these interactive formats.

The symposium itself went very smoothly, which was primarily due to the excellent local organization by Antoine Allombert, Marie Beurton-Aimar, Irène Durand, Nicole Lun and Robert Strandh. Without their willingness to organize the event and without the energy they put into it, the symposium would have never taken place. So a big thank you to all of them!

It was our intention to organize the European Lisp Symposium as an annual event right from the start. So the preparations for next year's ELS have already started, which will take place in Milan in 2009, at around the same time of the year (ca. end of May), and will be organized by Marco Antoniotti and António Leitão. More news will follow on the usual channels, but you can already start to prepare your ideas for ELS 2009!

Fear of DSLs?

In Fear of Parsers? I responded to Martin Fowler's posting ParserFear, arguing that more often than not, building new parsers for domain-specific languages may be too complicated for the benefits you can get from using domain-specific syntax.

To be clear about this: This is not an argument against domain-specific languages in general, only against domain-specific syntax. Domain-specific languages in Lisp are straightforward to build, easy to use once you are used to Lisp (which is not that hard either), and flexible enough to be adapted to future needs, without getting into the hairy details of designing and implementing suitable domain-specific parsers.

Fear of parsers?

Martin Fowler posts a lot about DSLs these days. In a recent post about ParserFear, he comments on an apparently typical reaction against creating one's own DSLs. That reaction seems to be that parsers are hard to write, and that it's easier to use XML instead because with XML, you get the parser for free. Martin Fowler then continues to explain why in his experience, parsers are not hard to implement, by contrasting a specific XML case with an alternative design using Antlr.

I think he misses the point, though. It's indeed the case that, taken by themselves, parsers are not very hard to write, especially if you stick to simple grammars. However, they could just be a too high investment for too little return.

This reminds me of a different story: A couple of years ago, Erich Gamma answered a few questions about patterns in one of his talks. One question was about which patterns he would not include anymore in the Design Patterns book. Among others, he mentioned the Singleton and the Visitor pattern, and his explanation for not including them was that he deems them too complicated.

Most people react puzzled when they hear this story. Yes, everybody who has tried to implement visitors knows that they are quite complicated, but in contrast, singletons seem extremely simple and straightforward to implement. However, the major point here is that they are too complicated for what they achieve: A singleton only guarantees that you get exactly one instance of a class, not more, not less. You might as well just introduce a global variable with that one instance and don't bother going through the minutiae of implementing the Singleton pattern correctly (which has border cases that you can get wrong after all, depending on what language you have to implement it in).

That's the major point: The effort has to be compared against the benefits you achieve. The same holds for writing parsers for DSLs. A domain-specific syntax simply doesn't buy you that much, but just creates another layer of code that needs to be maintained and can create follow-up problems, for example, when the syntax you designed happens to be too inflexible to be adapted to change requests in future versions of your code.

This is also the main reason why Lispers like s-expression. The rules for s-expressions are extremely simple, but at the same time also very flexible: The first element in a list determines the meaning of an expression, and all other elements are interpreted in terms of that first element. The same in XML: The tag determines the meaning of an expression, and everything that is nested inside it is interpreted in terms of the tag. An advantage of Lisp over XML is that you don't even need separate reading and processing steps of DOMs, since s-expressions are seamlessly embedded in the language itself.

So the main point of "parser fear" is not that parsers are hard, but just too hard for what they buy you.

ELS'08: Invited talk

Details of Marco Antoniotti's keynote talk, to be presented at the 1st European Lisp Symposium 2008 in Bordeaux on May 23, 2008, are now available at the symposium website.

Registration is open - watch out for reduced fees before the early registration deadline!

ELS'08: Programme published, registration, and more...

We have published the list of accepted papers that will be presented at the 1st European Lisp Symposium (ELS 2008) in Bordeaux/France on May 22-23. We have papers about temporal reasoning, context-oriented programming, visual programming, object-relational mappings, clim presentation types, custom specializers for object-oriented lisp, binary methods programming in CLOS.

Programme of the symposium.

We have also provided information about Bordeaux and about the social events programme accompanying the symposium. There will be a cocktail party, a dinner, and an optional excursion to the atlantic coast.

Information about Bordeaux, including how to reach Bordeaux by plane and by train.

Details about the social programme.

Registration for the symposium and for the optional excursion is open! Please take advantage of the reduced registration fees before the early registration deadline, April 25, 2008. Registering early helps us in planning the details of the symposium better. The early registration fee is 50€ for students and 120€ for regular participants.

The registration page.

You have to take care of accommodation yourself. We have provided a list of recommended hotels. For some of them, accounts for symposium participants are available.

The list of recommended hotels.

Looking forward to seeing you in Bordeaux!

ELS'08 News!

Hi everybody,

Here are some news about the upcoming 1st European Lisp Symposium, that will take place in Bordeaux/France on May 22-23, 2008.

First of all, registration is now open to everybody, and you can register for the symposium and the accompanying social event at the symposium website.

There is no programme yet, because the paper submissions are currently still under review. (The programme will be announced in early April.) However, Marco Antoniotti has kindly accepted an invitation to give the keynote for the symposium. More details on his keynote talk will follow soon.

On a related note, the call for work-in-progress papers is still open. We have actually just extended the deadline to April 4, 2008 for submissions for this track. This is a great opportunity to get early feedback for your current projects from other researchers, practitioners and educators.

Finally, we have added two pages to the website about Bordeaux in general and an optional social event that you can additionally book when you register for the symposium: A whole-day visit of the atlantic coast on the Saturday immediately after the symposium, which includes a boat trip, a seafood and white wine tasting session, a lunch, and a trip to the Great Dune of Pyla, the highest sand dune in Europe. Don't forget your swimsuit, if climbing the 107 meters of the dune invites you to dive into the ocean!

More news to follow as they arrive.

COP in Journal of Object Technology

There is a new article about Context-oriented Programming in the Journal of Object Technology.

It discusses context-oriented extensions for Common Lisp, Smalltalk and Java, namely ContextL, ContextS and ContextJ. There is a new ContextL example presented in this article that we haven't discussed in any of the previous papers, so it should be an interesting read for ContextL users as well.

As always, please feel free to send feedback and suggestions.