p-cos blog

Bertrand Meyer about John McCarthy...

2011-11-08T18:29:00.002+01:00

Nice essay about John McCarthy.

Beware the Purists...

2011-10-01T17:38:00.003+02:00

See Beware the Purists, Lest They Kill Your Innovation. Much of what is stated there also strongly applies to programming and programming languages...

The Perils of Partially Powered Languages

2011-08-30T22:58:00.001+02:00

Here is a worthwhile read: The Perils of Partially Powered Languages. It's from a Haskell perspective, but should apply to other non-underpowered languages as well. ;)

Complexity metrics other than code size don't mean that much...

2011-08-12T17:53:00.002+02:00

See here. To cite:

"El Emam and his colleagues repeated some of those experiments using bivariate analysis so that they could allocate a share of the blame to code size (measured by number of lines) and the metric in question. It turned out that code size accounted for all of the significant variation: in other words, the object-oriented metrics they looked at didn’t have any actual predictive power once they normalized for the number of lines of code. Herraiz and Hassan’s chapter in Making Software, which reports on an even larger study using open source software, reached the same conclusion:

'…for non-header files written in C language, all the complexity metrics are highly correlated with lines of code, and therefore the more complex metrics provide no further information that could not be measured simply with lines of code… In our opinion, there is a clear lesson from this study: syntactic complexity metrics cannot capture the whole picture of software complexity. Complexity metrics that are exclusively based on the structure of the program or the properties of the text…do not provide information on the amount of effort that is needed to comprehend a piece of code—or, at least, no more information than lines of code do.'"

Special variables in Java

2011-02-01T10:24:00.003+01:00

Wow. This is how complicated it gets to have he functionality of special variables in a language that really doesn't want them (and it's brought to you by Google): Google Guice

A non-hierarchical approach to object-oriented programming

2010-12-30T20:20:00.002+01:00

The Lisp historical archive web site just got reorganized. I have made a quick check of the contents, and found out that Howard I. Cannon's original technical report about Flavors - A non-hierarchical approach to object-oriented programming was finally made available as part of that archive. The report was originally written in 1979, was circulated around Lispers, but was never ever published as an actual technical report, although it is cited as such in several later papers by other authors. It describes the original object-oriented extension to the MIT Lisp Machine, heavily influenced by Smalltalk, but with multiple inheritance and method combinations added (but no multiple dispatch yet, which got only introduced in CommonLoops, a direct predecessor of CLOS). Although unpublished and clearly in an unfinished state, this report itself influenced a lot of other subsequent experiments with object-oriented extensions to Lisp dialects. Among other things, it already mentions the idea of exploring "meta-protocols" for making parts of the implementation of the object-oriented extension itself customizable, which was later investigated in much more detail as part of the work on the CLOS MOP (see also The Art of the Metaobject Protocol). And, of course, method combinations were already a very early predecessor of aspect-oriented programming.

It's good that this very important historical document is finally available!

Now is the time...

2010-11-08T12:44:00.004+01:00

Now is the time to switch programming languages: Oracle is the borg.

AOSD'11 conference

2010-06-14T14:37:00.002+02:00

Another interesting conference is coming up: The International Conference on Aspect-Oriented Software Development will be held in Porto de Galinhas, Brazil in March 2011. The conference chair is Shigeru Chiba, who is a long-term contributor to reflection and metaprogramming techniques himself, and who has assembled a diverse program committee covering not only core aspect technologies (like AspectJ-influenced approaches), but also explicitly Feature-oriented Programming, Context-oriented Programming, and also metaprogramming and reflection (which have been somewhat neglected in the aspect community for a long time, although they are clearly very relevant), among others. Dynamic languages are also mentioned in the call for research papers, so good papers based on languages like Lisp, Scheme, Smalltalk, and so on, are definitely welcome.

Another interesting element of this conference that I haven't seen before is that there will be two opportunities to submit papers: The first deadline is July 1, 2010, and the second deadline is October 1, 2010. The idea is that papers that fail to get accepted in the first round can be improved by their authors for a second round of reviews. It will be interesting to see if this works out.

International Lisp Conference '10

2010-06-07T17:15:00.002+02:00

The International Lisp Conference (ILC'10) is being held again, sooner than expected: It will be held in October 2010 in Reno, Nevada. This year, the conference will be co-located with OOPSLA/SPLASH, which also hosts the Dynamic Language Symposium. So this event is bound to be a very interesting combination. Paper submission for ILC'10 is open, submission deadline is August 1, so there is enough time to submit something. See the call for papers for more information.

Lisp Machine demonstration...

2010-04-25T15:04:00.003+02:00

I only now realized that besides the interesting talks and presentations to be given at this year's European Lisp Symposium, there will also be a demonstration of a TI Explorer Lisp Machine. That's pretty cool - I have never seen a Lisp Machine in action, but always wanted to see one, so this will be my first time. Looking forward to that. :)

Ah, yes, here is the link again: European Lisp Symposium, Lisbon, Portugal, May 6-7, 2010.

There will also be presentations by Kent Pitman and Matthias Felleisen whose abstracts sound pretty interesting, and I will try to give an overview of parallel programming in Common Lisp at the symposium as well. Still have to work on the slides for that one...

3rd European Lisp Symposium is very soon!

2010-04-13T15:16:00.003+02:00

The third European Lisp Symposium is less than a month away. I have received the following call for participation to redistribute, which I post here for everyone to read.

3rd European Lisp Symposium

May 6-7, 2010, Fundacao Calouste Gulbenkian, Lisbon, Portugal

Call for Participation

Registration for the 3rd European Lisp Symposium (ELS 2010) is now open.

Scope and Programme Highlights

The purpose of the European Lisp Symposium is to provide a forum for the discussion of all aspects of the design, implementation and application of any of the Lisp dialects. We encourage everyone interested in Lisp to participate.

As well as presentations of the accepted technical papers and tutorials, the programme features the following highlights:

Kent Pitman of HyperMeta Inc. will offer reflections on Lisp Past, Present and Future;
Pascal Costanza will lead a tutorial session on Parallel Programming in Common Lisp;
Matthias Felleisen of PLT will talk about languages for creating;
programming languages;
there will be opportunities for attendees to give lightning talks and demos of late-breaking work.

Social events

Symposium banquet (included with registration)
Excursion to Sintra (optional), for six centuries the favourite
Summer residence of the Kings of Portugal, who were attracted by cool climates and the beauty of the town's setting.

Programme Chair

Christophe Rhodes, Goldsmiths, University of London, UK

Local Chair

Antonio Leitao, Technical University of Lisbon, Portugal

Programme Committee

Marco Antoniotti, Universita Milano Bicocca, Italy
Giuseppe Attardi, Universita di Pisa, Italy
Pascal Costanza, Vrije Universiteit Brussel, Belgium
Irene Anne Durand, Universite Bordeaux I, France
Marc Feeley, Universite de Montreal, Canada
Ron Garret, Amalgamated Widgets Unlimited, USA
Gregor Kiczales, University of British Columbia, Canada
Antonio Leitao, Technical University of Lisbon, Portugal
Nick Levine, Ravenbrook Ltd, UK
Scott McKay, ITA Software, Inc., USA
Peter Norvig, Google Inc., USA
Kent Pitman, PTC, USA
Christian Queinnec, Universite Pierre et Marie Curie, France
Robert Strandh, Universite Bordeaux I, France
Didier Verna, EPITA Research and Development Laboratory, France
Barry Wilkes, Citi, UK
Taiichi Yuasa, Kyoto University, Japan

Registration

Registration is open and costs EUR120 (EUR60 for students) until 22nd April, and EUR200 (EUR120 for students) afterwards.

Registration includes a copy of the proceedings, coffee breaks, and the symposium banquet. Accommodation is not included.

Filtered functions

2009-12-04T23:00:00.002+01:00

I am very excited that I can finally annouce a public release of filtered functions, an extension of generic functions that Charlotte Herzeel, Jorge Vallejos, and myself have developed some time ago and that we are very excited about because it seems to be quite powerful in a number of very different scenarios. It took a while to release filtered functions, because it is a quite non-trivial extension of generic functions and requires a CLOS MOP implementation that is compliant with the AMOP specification to quite a deep level. Therefore, this required some serious preparation in the form of a much improved Closer to MOP library, that I released today as well.

You can find filtered functions and Closer to MOP at the Closer project website. Below you will find a general overview of the concept.

Filtered functions are an extension of generic functions, extended with a filtering step where the arguments received by a generic function are mapped to other values based on user-defined mapping functions. Those filtered values are then used to perform the actual selection and execution of applicable methods. Nevertheless, the methods that are eventually executed see the original objects as received by the generic function, and not the filtered ones.

Here are some examples to illustrate the expressive power of filtered functions.

Factorial

In order to be able to use filtered functions, we need to have filter functions that map received arguments to values that we actually want to base our dispatch on. For the factorial function, we want to distinguish between negative and positive numbers, and the number zero. For that we can just use the Common Lisp function SIGNUM that returns +1 for positive numbers, -1 for negative numbers, and just 0 for the number 0. The filtered function FAC can thus be defined as follows.


(define-filtered-function fac (n)
  (:filters (:sign #'signum)))

DEFINE-FILTERED-FUNCTION is exactly like DEFGENERIC, except that it can also define one or more filters. Here, it defines a filter with the name :SIGN wich specifices that the function SIGNUM is to be used for filtering.

We can now define methods for FAC:


(defmethod fac :filter :sign ((n (eql +1)))
  (* n (fac (- n 1))))

(defmethod fac :filter :sign ((n (eql 0)))
  1)

(defmethod fac :filter :sign ((n (eql -1)))
  (error "Fac not defined for negative numbers."))

Here, we use the qualifiers :FILTER :SIGN in the method definitions to indicate that we indeed want to use the :SIGN filter for method selection. We then use EQL specializers to ensure that the method definitions are applicable for the three different cases that SIGNUM yields. Remember that the method bodies always see the original arguments, not the filtered ones, and this is why the FAC methods can do the correct computations.

State pattern

Filtered functions can be used to dispatch methods based on the state of an argument passed to a filtered function, which enables expressing State-like idioms. Assume the following simple CLOS class is defined for implementing a stack.


(defconstant +stack-size+ 10)

(defclass stack ()
  ((contents :initform (make-array +stack-size+)
             :reader stack-contents))
   (index :initform 0
          :accessor stack-index)))

Instances of this class have three different states: Such a stack can either be empty, or full, or anywhere in between (in 'normal' state). We can express this as a function that recognizes the state of a stack.


(defun stack-state (stack)
  (cond ((<= (stack-index stack) 0) 'empty)
        ((>= (stack-index stack) +stack-size+) 'full)
        (t 'normal)))

It is now straightforward to use stack-state in a filter named :state for the typical stack operations.


(define-filtered-function stack-push (stack value)
  (:filters (:state #'stack-state)))

(define-filtered-function stack-pop (stack)
  (:filters (:state #'stack-state)))

(define-filtered-function stack-emptyp (stack)
  (:filters (:state #'stack-state)))

We can now group the behavior of a stack according to its different states. Note that for 'normal' state, we do not need to mention the use of any filter here, because the methods are not specialized on anything specific anyway. (Filtered functions always allow for 'regular' methods alongside the filtered methods.)


;;; Normal state

(defmethod stack-push (stack value)
  (setf (aref (stack-contents stack)
              (stack-index stack))
        value)
  (incf (stack-index stack)))

(defmethod stack-pop (stack)
   (decf (stack-index stack))
   (aref (stack-contents stack)
         (stack-index stack)))

(defmethod stack-emptyp (stack)
  nil)

;;; Empty state

(defmethod stack-pop :filter :state ((stack (eql 'empty)))
  (error "Stack is empty."))

(defmethod stack-emptyp :filter :state ((stack (eql 'empty)))
  t)

;;; Full state

(defmethod stack-push :filter :state ((stack (eql 'full)) value)
  (error "Stack is full."))

Note that we used a derived state function here, that determines the state of the stack based on some of its other properties. Since filter functions can be any functions, we could also use the reader of a slot as a filter function, and thus have the behavior of a filtered function depend on the explicit state of an object.

Filtered functions can do a lot more: As already mentioned, they can use more than one filter; filter functions can see all the arguments a generic function receives; and filters can be guarded, which means that methods that use a particular filter may be completely ignored if the arguments don't fulfil a certain predicate. You can read the paper Filtered Dispatch that I co-authored with Charlotte Herzeel, Jorge Vallejos and Theo D'Hondt for a more thorough introduction, background information and semantics, and which also includes an extensible metacircular Lisp interpreter as an example, based on implementing EVAL as a filtered function.

European Lisp Symposium 2009 - programme details!

2009-04-25T14:32:00.002+02:00

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

2009-03-30T00:27:00.003+02:00

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

2009-03-12T16:04:00.003+01:00

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

2009-01-26T14:23:00.002+01:00

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

2008-09-18T19:46:00.002+02:00

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

Reflection for the Masses

2008-09-14T16:21:00.002+02:00

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

2008-06-01T23:17:00.002+02:00

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

2008-06-01T21:13:00.002+02:00

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

2008-05-27T14:11:00.002+02:00

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?

2008-05-26T10:38:00.003+02:00

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?

2008-05-20T21:02:00.002+02:00

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

2008-04-18T14:06:00.002+02:00

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

2008-04-09T12:31:00.002+02:00

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!

2008-03-18T23:08:00.001+01:00

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

2008-03-08T16:22:00.003+01:00

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.

Origin of Advice

2007-12-19T21:57:00.000+01:00

Apparently, Gary King needs advice a lot. This reminded me that I posted an article about the origin of advice some time ago in the AOSD mailing list. I think it's a good idea to repost it here to make it available to others as well, so here we go. (I have links for almost all the literature references at the bottom of this article.)

The notion behind advice can be traced back to a paper by Oliver Selfridge [Selfridge 1958]. He introduced the notion of demons that record events as they occur, recognize patterns in those events, and can trigger subsequent events according to patterns that they care about.

A first software system that was obviously heavily influenced by that paper was called PILOT and is described in Warren Teitelman's PhD thesis [Teitelman 1966]. The PhD thesis was supervised by Marvin Minsky, but additionally Warren Teitelman mentions Oliver Selfridge as a strong influence in his acknowledgements. Marvin Minsky and Oliver Selfridge worked both at MIT back then. Anyway, that is the work in which the notion of advice, very similar to before and after advice as we know them today, was actually first introduced. Warren Teitelman later added the concept of advice to BBN Lisp, which was then bought/licensed (?) by Xerox PARC and became Interlisp.

Later, the notion of demons was mentioned in a seminal paper by Marvin Minsky [Minsky 1974] that spawned an interest in framework-based knowledge representation systems. Among others, Daniel Bobrow and Terry Winograd developed and described KRL [Bobrow, Winograd 1976], which was based on the ideas in Marvin Minsky's paper. If I understand correctly, before/after demons played an important role in such systems.

A little bit later, Howard Cannon developed Flavors at MIT, the first object-oriented extension for Lisp, strongly influenced by Alan Kay's Smalltalk. Howard Cannon had written a very influential paper [Cannon 1979-2003] that was, unfortunately, never officially published. He explicitly mentions before/after demons, as do other publications about Flavors, for example [Weinreb, Moon 1980].

I have a copy of Howard Cannon's paper availabe, and I have asked him to make it publicly available, but he still hasn't done this (yet). His is a mind-blowing paper that introduces multiple inheritance, method combinations based on macros - i.e. before and after demons and a first precursor to around methods -, and the notion of meta-protocols that obviously later on turned into metaobject protocols.

The experiences with KRL and Flavors had then been integrated at Xerox PARC into LOOPS (Lisp Object-Oriented Programming System), foremostly by Daniel Bobrow and Mark Stefik, implemented in Interlisp. There is a nice overview page about LOOPS and a download page for the papers mentioned there.

Flavors and LOOPS were chosen as the main bases for the Common Lisp Object System (CLOS) as part of the ANSI standardization of Common Lisp. CLOS was developed by representatives of the various existing object-oriented extensions for Lisp. LOOPS / Xerox PARC was represented by Daniel Bobrow and Gregor Kiczales. This was around 1986 - 1988.

CLOS has before/after/around methods. I haven't been able to spot when around methods entered the scene, whether this was already part of LOOPS or whether this was an addition in CLOS. In Flavors, there were only before/after methods, but there was an extra concept called wrappers that effectively allowed one to express the same thing as around methods in CLOS.

One of the most impressive outcomes of the efforts behind LOOPS and CLOS is the book The Art of the Metaobject Protocol [Kiczales, des Rivières, Bobrow 1991], which I think is one of the most important books in the history of computer science (and Alan Kay seems to agree).

Crista Lopes' paper [Lopes 2002] describes the subsequent history how metaobject protocols were turned into what we think of as aspect-oriented programming today. The main motivations, as far as I understand them, were a) to move from a runtime-based approach, which is natural for metaobject protocols, towards a compile-time based approach and b) to make some of the benefits of being able to manipulate the meta-level available to purely base-level code. Advice play an important role in aspect-oriented programming, but instead of advising just single functions, you can advise whole pointcuts, which are essentially sets of functions described in (more or less) declarative ways.

Robert Hirschfeld, myself and others have taken a different turn with Context-oriented Programming, and focus on a more dynamic approach again. We have taken the idea of crosscutting concerns that emerged in the AOSD community, but dropped the idea of pointcuts, and instead concentrated on new and interesting ways to dynamically activate and deactivate layers, which are potentially crosscutting behavioral program variations. Since you can add new layers at any point in time, you can also effectively add new levels of before/after/around methods at runtime as needed, something that can be achieved in plain CLOS only statically through new user-defined method combinations, or requires recompilation in aspect-oriented language extensions like AspectJ. Here are some links for Context-oriented Programming:

Context-oriented Programming at Hasso-Plattner Institut.

My research page with sections on ContextL and Context-oriented Programming.

The ContextL project page.

I agree that advice are an important concept in programming, but we have still not seen all the possible and interesting variations yet. Although they have a long history already, there is still a future ahead for them.

References

[Bobrow, Winograd 1976] Daniel Bobrow and Terry Winograd, An Overview of KRL, A Knowledge Representation Language.

[Cannon 1979-2003] Howard Cannon, Flavors - A Non-Hierarchical Approach to Object-Oriented Programming. Unpublished draft.

[Kiczales, des Rivières, Bobrow 1991] Gregor Kiczales, Jim des Rivières, Daniel G. Bobrow, The Art of the Metaobject Protocol, MIT Press, 1991.

[Lopes 2002] Cristina Videira Lopes, AOP: A Historical Perspective.

[Minsky 1974] Marvin Minsky, A Framework for Representing Knowledge.

[Selfridge 1958] Oliver G. Selfridge, Pandemonium, Mechanization of Though Processes: Proceedings of a Symposium held at the National Physics Laboratory on 24-27 Nov. 1958, volume I., (NPL Symposium no. 10, HMSO, 1959).

[Teitelman 1966] Warren Teitelman, PILOT: A Step Toward Man-Computer Symbiosis.

[Weinreb, Moon 1980] Daniel Weinreb and David Moon, Flavors: Message Passing in the Lisp Machine.

Reflection in Potsdam

2007-12-19T21:25:00.000+01:00

Charlotte Herzeel and I had been invited by Robert Hirschfeld to give presentations at the Hasso-Plattner-Institut in Potsdam, Germany about the CLOS Metaobject Protocol and 3-Lisp about two weeks ago. These presentations have been recorded and are now online for your viewing pleasure:

Pascal Costanza, The CLOS Metaobject Protocol (in German)

Charlotte Herzeel, Reflecting on 3-Lisp (in English)

You need RealPlayer to see this.

European Lisp Symposium mentioned in Linux Magazin

2007-12-10T23:19:00.000+01:00

The 1st European Lisp Symposium is mentioned in Linux Magazin online (in German language).

European Lisp Symposium 2008 - Call for Papers

2007-12-06T08:54:00.000+01:00

1st European Lisp Symposium

Bordeaux, France, May 22-23, 2008

LaBRI, Université Bordeaux 1

Important Dates

Submission of research papers: February 11, 2008

Work-in-progress papers: March 24, 2008

Author notification: April 7, 2008

First final versions due: April 28, 2008

Accepted research papers will be invited for a special issue of the Journal of Universal Computer Science (J.UCS). See the symposium website for more details.

Scope

The European Lisp Symposium 2008 invites high quality papers about novel research results, insights and lessons learned from practical applications, and educational perspectives, all involving Lisp dialects, including Common Lisp, Scheme, ISLISP, Dylan, and so on.

Topics include, but are not limited to:

Language design and implementation techniques

Language integration, interoperation and deployment

Experience reports and case studies

Reflection and meta-level architectures

Educational approaches

Software adaptation and evolution

Configuration management

Artificial intelligence

Large and ultra-large-scale systems

Development methodologies

Development support and environments

Persistent systems

Scientific computing

Parallel and distributed computing

Data mining

Semantic web

Dynamic optimization

Innovative applications

Hardware and virtual machine support

Domain-oriented programming

We also encourage submissions about past approaches that have been largely forgotten about, as long as they are presented in a new setting.

We invite submissions in two categories:
original contributions and work-in-progress papers.

Original contributions have neither been published previously nor are under review by other refereed events or publications. Research papers should describe work that advances the current state of the art, or presents old results from a new perspective. Experience papers should be of broad interest and should describe insights gained from substantive practical applications. The program committee will evaluate each contributed paper based on its relevance, significance, clarity, and originality.

Accepted papers will be published in the Journal of Universal Computer Science (J.UCS). Authors of accepted papers are expected to present their work at the symposium main track in Bordeaux on May 23, 2008.

Work in progress describes ongoing work that is not ready for publication yet, but would benefit strongly from feedback by other researchers, practitioners and educators. Such contributions will not be published in the symposium proceedings, but will be made available at the symposium website. The work-in-progress track will be organized as a series of writers' workshops where authors work together to improve their papers. Some authors who submit papers for the main track will be suggested to contribute their work in this track instead, if the program committee decides that their submission is not yet ready for a publication.

The writers' workshops will take place at the symposium in Bordeaux on May 22, 2008.

Submissions

Papers for the main track must be submitted electronically, preferably as PDF or PostScript file (level 1 or 2). However, submissions in RTF or Word format are also accepted. Initial submissions may not exceed 15 pages in the J.UCS style, including all appendices. (Invited papers for the journal publication will have a page limitation of 25 pages in the same format.) See the symposium website for more details, including about the submission procedure.

Papers for the work-in-progress track may be in PDF, PostScript level 1 or 2, RTF or Word, and may not exceed 25 pages. There are no further requirements on their format. Papers for the work-in-progress track must be sent via email to pascal.costanza@vub.ac.be.

Program Chair

Pascal Costanza, Vrije Universiteit Brussel, Belgium

Program Committee

Marco Antoniotti, Universita Milano Bicocca, Italy

Marie Beurton-Aimar, Université Bordeaux 1, France

Jerry Boetje, College of Charlston, USA

Theo D'Hondt, Vrije Universiteit Brussel, Belgium

Irène Durand, Université Bordeaux 1, France

Marc Feeley, Université de Montréal, Canada

Erick Gallesio, Universite de Nice / Sophia Antipolis, France

Rainer Joswig, Independent Consultant, Germany

António Leitão, Technical University of Lisbon, Portugal

Henry Lieberman, MIT, USA

Scott McKay, ITA Software, Inc., USA

Ralf Möller, Hamburg University of Technology, Germany

Nicolas Neuss, Universität Karlsruhe, Germany

Kent Pitman, PTC, USA

Christophe Rhodes, Goldsmiths College, University of London, United Kingdom

Jeffrey Mark Siskind, Purdue University, USA

Didier Verna, EPITA Research and Development Laboratory, France

Lisp success story from Hungary

2007-11-03T18:43:00.000+01:00

[Levente Mészáros posted the following Lisp success story to comp.lang.lisp. I reproduce it here with kind permission so that it is also available as a blog entry. In other words, the following is not written by me, but by Levy.]

We are a small group of friends (3-5) who left the "professional" programming scene about one and a half year ago to start our own Lisp business.

In July, 2007 we started working on a project for the Hungarian government with a very tight deadline. In mid October the system showed first life signs and now we can say it is extensively used by thousands of users. In spite of the short timeframe and the remaining glitches it was a surprise even for us that the system is able to handle such a load.

Unfortunately the application is not publicly accessible, so we can't provide a URL, but we can give some of the details. It is used for gathering data from the Hungarian communes to help the budget planning.

The entire system is based on opensource software, it runs on multiple SBCLs behind an apache load balancer. The data is stored in a PostgreSQL server.

We have around 4000 registered users, average 300 online and more than 500 at peak times. There are 7000-10000 logins per day.

We use the following Common Lisp libraries. Some of which are ours and some of which are built by others. Many thanks for their efforts, especially to the SBCL developers!

Data storage/persistence
- cl-perec
- cl-rdbms
- cl-postgres (postmodern)

Web GUI
- cl-dwim (the umbrella project)
- UCW
- yaclml
- parenscript
- rfc*

PDF exporting
- cl-pdf
- cl-typesetting

Unit testing
- stefil
- SLIME and emacs with customizations

MOP
- computed-class
- contextl

Misc
- bind
- alexandria
- iterate
- cl-def
- cl-l10n
- cl-graphviz
- cl-serializer
- defclass-star
- local-time
- cffi
- babel
- verrazano

and more...

Main software components:
- Ubuntu linux 6.10
- PostgreSQL 8.2
- SBCL 1.0.10
- Apache2 (due to various headaches soon to be replaced by a lisp based load balancer)

Hardware:
- 10 nodes with two dual core x86-64 CPUs summing up to 40 cores altogether, each node has 3 Gbytes ram.
- Currently we use one of the nodes as database server but soon it will be replaced with another server with 2 or 4 quad core x86-64 CPUs, 300 GByte disk in raid 5 and 16 GBytes ram.

Some people say Lisp is dead but seems like there's life after death... ;-)

ContextL Survey September 2007

2007-09-03T14:30:00.001+02:00

Context-dependent behavior is becoming increasingly important for a wide range of application domains. Unfortunately, mainstream programming languages do not provide mechanisms that enable software entities to adapt their behavior dynamically to the current execution context. In collaboration with various researchers, we have developed a new programming technique called "Context-oriented Programming" (COP).

ContextL is our first fully implemented and currently most mature programming language extension for COP and is built on top of the Common Lisp Object System (CLOS). ContextL has first been made available to the public in early 2005, and has already been adopted by a number of programmers. We would now like to assess how well ContextL has been received so far.

Please consider participating in our first survey about ContextL - this will help us a lot to develop ContextL and related projects further (like Closer to MOP, etc.).

You can find the survey and more information about it at http://prog.vub.ac.be/~pcostanza/COP/survey.html.

ECOOP'07 Lisp Dinner

2007-07-26T13:20:00.000+02:00

As a social event attached to the 4th European Lisp Workshop, we are planning to have a dinner on Monday, the 30th of July in Berlin, starting at 19:30 hours. We have not yet decided what the location will be, and this depends on how many people will participate. The dinner will be open to anyone.

If you want to attend, please send a short email notice to Hans Hübner. Also let him know if you have special dinner needs or wishes.

Lisp meeting in The Hague this Sunday

2007-06-28T17:08:00.000+02:00

I am forwarding this announcement from Tayssir John Gabbour:

We're hosting a Lisp meeting in The Hague this Sunday. At least ten
people should be here, with a broad range of experiences and
interests.

For those interested in Lisp businesses, this meeting will be at the
offices of a growing Lisp-using company which already has multiple
commercial projects. You'll be able to see up-close what sorts of
issues arise. I personally hope that these meetings won't just be
episodic affairs, but offer a practical service to interested Lisp
users.

To counterbalance boring business issues, Pascal Costanza is offering
an entertainingly philosophical talk about the history of reflection
and metaprogramming in the Lisp family. (If you were ever curious what
3-Lisp and its "infinite reflective tower" is all about, you'll no
doubt find this interesting.)

This is an informal meeting, so no registration is needed: feel free
to come as you wish, and I hope you enjoy it. If you need directions
or a hotel room, there's more info at: http://wiki.alu.org/BeNeLux.

Tayssir

AMOP at Google Book Search

2007-06-25T17:56:00.000+02:00

While checking some links for my previous posting I have found out that Google Book Search provides the full text of The Art of Metaobject Protocol online. That's nice.

Classes in the Metaobject Protocol

2007-06-25T12:02:00.000+02:00

Dr. Dobb's Portal has republished another classic Lisp article, again by Nick Bourbaki (a pseudonym of Richard Gabriel). It's an introduction to the CLOS Metaobject Protocol which is more technical than others I have read - so may be harder to understand for newbies - but at the same time provides more insight into some of the internal details of the CLOS MOP. Although this is an old article, it's very close to the actual CLOS MOP specification, with only one serious deviation as far as I can tell. The deviation is the fact that slot-value-using-class is specialized on slot names in that article, while they are actually specialized on slot definition metaobjects in the "real" CLOS MOP specification. The reason for this deviation is that for most of the time during the standardization of CLOS and its MOP, slot-value-using-class was indeed supposed to be specialized on slot names (like slot-unbound and slot-missing in ANSI Common Lisp), but that was changed only very late in the game before publication of The Art of the Metaobject Protocol.

Anyway, the information in that article is still valid, so I can recommend it.

Dr. Dobb's Classic Lisp Articles

2007-06-03T16:28:00.001+02:00

Recently, I have noticed that the online version of Dr. Dobb's Journal published an article about multitasking in Common Lisp. What was weird to me was that it reads like a rather old article mentioning techniques that, if I understand correctly, were popular in the 1980's, and especially mentioning a Common Lisp implementation that has not been maintained for probably over a decade. So I asked around in comp.lang.lisp whether anyone had an idea what this was about.

Surprisingly, Jon Erickson, editor of Dr. Dobb's Journal, responded to that question and explained that they routinely get requests for classic articles that are 15-20 years old, and so they indeed regularly republish such articles from the past. Since they are responsible for the archives of a number of publications, such as AI Expert, C/C++ Users Journal, BYTE, and Computer Language, there are probably quite a few nuggets to be rediscovered here.

For example, earlier this year they have already published an article by Paul Graham about graphic objects, originally from 1988. Just yesterday, they have published a very interesting article by Nick Bourbaki about dynamic programming. Nick Bourbaki is actually Richard Gabriel's pseudonym that he used in some of his writings in the early 1990's - see Worse Is Better and also Nickieben Bourbaki.

European Lisp Workshop '07 - news

2007-05-17T15:12:00.000+02:00

As already announced, this year's European Lisp Workshop will be held in Berlin on July 30, again in conjunction with ECOOP. There are two noteworthy news items:

We are happy to announce that Alexander Repenning will be giving a keynote presentation about Antiobjects: Mapping Game AI to Massively Parallel Architectures using Collaborative Diffusion.

The submission deadline for papers, essays and breakout group proposals has been extended to May 31. Notifications of acceptance will be sent out on June 8, one week before the early registration deadline.

See the workshop website for more information.

ELW'07

2007-04-24T19:49:00.000+02:00

There will be a new instance of the European Lisp Workshop at ECOOP 2007 in Berlin, Germany on July 30. The deadline for submission of long papers, short essays and/or proposals for breakout groups is May 13. Please see the ELW'07 website for more information.

Reflective Layer Activation in ContextL

2007-04-24T19:33:00.000+02:00

I have just uploaded the paper Reflective Layer Activation in ContextL to my website that we have presented at this year's ACM Symposium on Applied Computing.

This paper describes some aspects of the metaobject protocol of ContextL. This is not exactly the same version as presented at the symposium, but the paper has been updated to reflect the new API in ContextL 0.4. However, apart from the resulting changes of function names and a few other minor edits, the contents have remained the same.

ContextL 0.40.

2007-04-21T23:47:00.000+02:00

I have just released version 0.40 of ContextL. The idea is that this version is feature-complete with regard to the feature set of the upcoming 1.0 release. The goal is now to test this version extensively, and to write a documentation of the current features and the API of ContextL before version 1.0 is eventually released.

There have been some changes in the API which are listed at the ContextL homepage. These are mostly cosmetic changes, like better names for functions, etc.

However, there are also some new features. The most interesting ones are probably several readers for the main ContextL metaclasses, such that the introspective part of ContextL is now complete, and a function current-layer-context. The latter can be used to capture the set of currently active layers, which can later be reinstalled for example with funcall-with-layer-context. Current-layer-context should be interesting for example to "inherit" active layers to/from threads in multithreaded Common Lisp implementations, or to capture active layers alongside continuations such that they can both be reinstalled together later on. This could, for example, be interesting in conjunction with continuation-based web frameworks.

For more details, see the ContextL homepage and announcements/discussions in the closer-devel mailing list.

My impressions of ILC'07

2007-04-09T16:43:00.000+02:00

I am posting this as an individual member of the Lisp community. I am not speaking for the ILC'07 organizers. (Oh man... ;)

I am very happy that ILC'07 turned out to be so successful. This hasn't been always clear during the preparations, so I guess all the organizers breathed a sigh of relief when the numbers of registrations started to increase (and we suddenly had to come up with ideas how to manage a situation in which we nearly had too many registrations ;).

Among the "generic" highlights, I personally enjoyed the atmosphere a lot. I am convinced that this is mainly due to the fact that almost everyone had their accommodation at the same place. In my experience, conferences where this is the case are typically more successful - you already see the participants in the morning during breakfast, you have a lot more time to talk to each other, and so on.

For me, it was also nice to see so many people again. On average, the number of smart people is a lot higher at Lisp meetings than elsewhere, so there is always a chance to have some very interesting discussions with very different perspectives provided by everyone.

About the conference itself, I am happy that the program chair (JonL White) has carefully selected a very interesting set of presentations. Almost all talks were of high quality, covering a broad range of topics with only a couple of downers. My personal highlights have been:

Antonio Leitao's work on translating Java source code to idiomatic (!) Common Lisp sources. He has already done the reverse (translating a subset of Common Lisp to Java) in the past and is now heading towards a solution that potentially improves the situation on the library front for Common Lisp. The interesting aspect here is the focus on generating idiomatic code, i.e., code as if it had been written manually by experts in the respective target languages.

Mike Sperber's illuminating talk about R6RS Scheme. I had some fears wrt having this presentation for an audience that mostly consists of Lispers, but non-Schemers. However, Mike has given a very entertaining talk and helped everyone to have a better idea about the goals of R6RS. (IMHO, it's important that Schemers and Lispers talk more to each other because both sides can learn from each other. I'm glad that ILC'07 has helped improve the situation a little bit.)

Manuel Serrano has given a very impressive presentation about his HOP framework for developing web applications in Scheme. It's good to see that there are a couple of approaches that head in the right direction of enabling the creation of GUIs that makes users' lives easier instead of focusing on solving technicalities of accidental elements in the underlying technology (for example, the infamous "back" button). I see HOP in the same line as Marc Battyani's (unfortunately unpublished) web framework, but as far as I can tell, Manuel has gone a few steps further.

Alexander Repenning had a paper about X-expressions in XMLisp, which sounds a lot more boring than what he actually presented. This is not yet another library for dealing with XML, but actually modifies the Common Lisp reader (parser) to treat XML as syntax for literal CLOS objects. The applications that he has built on top of that technology are very impressive indeed.

Clemens Fruhwirth's Liskell is actually a very simple idea. He takes GHC - a widely used implementation of Haskell - and replaces the Haskell syntax with s-expressions. This enables, among other things, the inclusion of macros. I have always wanted to take a closer look at Haskell, but its syntax always put me off. Now I don't have an excuse anymore. ;)

For obviously personal reasons, I am also very happy that Charlotte Herzeel's presentation about HALO is so well-received - she got a lot of positive feedback for her presentation. However, it is only an overview of HALO, there is still more to come. I hope that we can report on some exciting results soon.

On the negative side about ILC'07, it seems to me that the program was maybe a little too packed - we had to get up very early in the morning (very hard for me ;), and there was maybe not enough time to engage in discussions or even do some work with other attendees. We have tried to establish a breakout group format, but apparently we haven't found the right approach yet. Ralf Mattes suggested a birds-of-a-feather-sessions format to me, so maybe that's something we should look into for the future.

A real downer was the annual meeting of the Associations of Lisp Users (ALU). It wasn't the first time they promised to become more "professional", but their presentation to the ALU members was worse than average. I hope they will manage to get their act together. Otherwise, it will be hard for them to be taken seriously by the Lisp community in the long run. It is worth noting, though, that they are responsible for backing the International Lisp Conference, so they must be doing something right... ;)

Fortunately, the rest of the conference didn't suffer from the ALU meeting - the day after was as good as, or maybe even a little more exciting than, the other days on all levels.

Next on the schedule is the European Lisp Workshop, co-located with ECOOP 2007 and taking place in Berlin on July 30, and most likely sometime early next year another instance of the European Common Lisp Meeting.

Lisp Bleep Survivalism

2007-03-08T23:05:00.000+01:00

A few tidbits:

Registrations for the International Lisp Conference 2007 are coming in like crazy, and we are soon running out of rooms at the Clare College. There are only three days left until the early registration deadline with reduced fees, so there are enough reasons to better hurry up. ;)

New videoclips by Motor and Nine Inch Nails.

This is the last posting about music to this blog, since the postings here occur, for example, at Planet Lisp. So in order to stop boring Lispers about music they are not interested in, I will post all music-related ramblings to the freshly brewed infox_blog instead.

What is the point of macros?

2007-02-27T23:27:00.000+01:00

One of the distinguishing features of Lisp and Scheme is the ability to define macros that allow you to extend the base language with new language constructs. Here are two examples what this actually means and why this is a good idea.

Let's take a common idiom from Java: Whenever you want to open a file, process its contents, and close it again afterwards, you have to write code roughly like this:


FileInputStream in = new FileInputStream(filename);
try {
   doSomething(in);
} finally {
   in.close();
}

Note how the orange code is the code that you are actually interested in: That's the part that states which file you want to open, that you want to open it for reading, and that you want to do something with the file. The rest is just idiomatic code that you have to write just to make the machinery work: You declare a variable outside of the try block (this is important for the visibility of the variable!), and you have to put the call of the close method in a finally block to ensure that the file is always closed even when an exception occurs.

The problem here is that you have to write this code over and over and over again, and everytime you write this code, you have to get the details right. For example, when I was still a Java hacker, I always have put the variable declaration inside the try block, just to get the error message from the compiler that this is wrong. This is annoying - it would be nice if I didn't have to think about this. (I have actually gotten it wrong again in the first version of this posting. Go figure.)

Here is the same code in Common Lisp:


(let ((in (open filename)))
  (unwind-protect
      (do-something in)
    (close in)))

This is not yet an improvement: The orange part of the code is still deep down in other code that just ensures that the machinery for opening and closing the file works. I still have to declare the variable first (here with a let), I still have to use the Lisp-equivalent of try-finally (here it's called unwind-protect), and I still have to ensure that the closing of the file happens as part of the clean-up step of an unwind-protect.

However, Lisp gives us a way to get rid of the idiomatic code. What we would actually like to write is this:



(with-input-file (in filename)
  (do-something in))

This code states exactly what we want and nothing else: We want to execute some code with an open file bound to some variable, and we implicitly want to ensure that it is closed again at the end of this code fragment.

Here is a macro that defines this construct:


(defmacro with-input-file ((variable filename) &body body)
  `(let ((,variable (open ,filename))
     (unwind-protect
         (progn ,@body)
       (close ,variable))))

Here is an explanation of the code:

The macro is defined with defmacro and we name it like the language construct we want to build. It takes two variables: a variable name and a piece of code that will give us the filename in the resulting code. It also takes a body of code for the with-input-file construct.

The macro creates a piece of code that the Lisp compiler should use instead of the original code that uses the with-input-file construct: We basically define a code template in which the variable, filename and body spots are filled in with the parameters that the macro receives.

Some minor details: The progn groups a number of expressions into one - this is similar to grouping code in a pair of curly braces in Java. The backquote, comma and comma-at notations are there to clarify how the parameters should be inserted - that's something that you can better learn in good Lisp tutorials.

Although writing macros takes a little practice, it is very straightforward once you are used to doing this. Macros help you to avoid typing a lot of idiomatic code: whenever you notice some coding pattern, you can put it in some macro and then use it instead.

Syntactic Abstractions

Let's get a little closer to the heart of what macros actually are: They provide you with a way to define syntactic abstractions. Abstractions are used for hiding away implementation details that client code should not be interested in. For example, in classes you can define private fields and methods for internal use and define a public interface that client code has to go through to ensure that the internal details are always used properly. Likewise, with functional abstractions - closures - you can pass around a function that can refer to variables in its lexical environment without giving anyone direct access to these lexical variables.

Many implementation details can be hidden very well with such abstraction mechanisms. However, others cannot be hidden well, and this is when macros become interesting.

For example, assume that your language doesn't provide any iteration constructs but requires you to use recursion instead. You can relatively easily build your own iteration constructs - for example a while function - like this in Lisp:


(defun while-function (predicate block)
  (if (not (funcall predicate)) (return))
  (funcall block)
  (while-function predicate block))

This function works as follows: It takes a predicate function and a block of code, also provided as a function. When calling the predicate (with funcall) returns false, the while-function returns. Otherwise, the block is executed (again with funcall) and then the while-function calls itself again.

Here is an example of using the while-function:


(let ((i 0))
  (while-function (lambda () (< i 10))
    (lambda ()
      (print i)
      (incf i))))

This code fragment increments i from 0 up to 10 and prints i at each step. This piece of code doesn't look very nice. One reason is that Lisp's lambda construct is somewhat lengthy. Smalltalk, Ruby, and other languages have nicer syntax for lambda expressions, and would make this code shorter. However, even then there is a problem here: We still have to write idiomatic code to write a while loop although we are actually not interested in the idiom. Here, the idiomatic element is the use of a lambda expression to ensure that some code is not immediatily executed, but only later under the control of the while-function. However, what we actually want to say is this, which doesn't contain any idiomatic code at all:


(let ((i 0))
  (while (< i 10)
    (print i)
    (incf i)))

And, as you might have guessed, here is a macro to implement this while construct:


(defmacro while (expression &body body)
  `(while-function (lambda () ,expression)
     (lambda () ,@body)))

This macro uses the while-function in the code that it creates. This is actually one of the typical ways to write Lisp code: We first define the functional (or object-oriented, or imperative, or whatever) abstractions, and then we add some syntactic layer on top to make the code look nicer, and especially to hide away implementation details that we cannot hide otherwise.

Why is it so interesting to hide away implementation details, like the use of lambda expressions to delay evaluation? Well, we could actually decide not to use lambda expressions at all in our expansion. Here is an alternative implementation of the while macro:


(defmacro while (expression &body body)
  `(tagbody
     start (if (not ,expression) (go end))
           ,@body
           (go start)
     end))

Yes, Common Lisp provides the tagbody construct inside which you can use go, i.e., a goto statement! Gotos are not a very good idea to use in your own code, but gotos are very useful for generating efficient code in macros. In this second implementation of the while macro, there is for example no need anymore to allocate space for the closures that the two lambda expressions create, because we can simply jump around the code to delay its execution.

Of course, this is a toy example, so the little gain in efficiency here is probably not worth the effort. However, what is important is that the "API" for the while macro hasn't changed at all compared to the first version. You still write this:


(let ((i 0))
  (while (< i 10)
    (print i)
    (incf i)))

That's one of the important advantages of abstractions: You can change internal implementation details while all the client code can be left unchanged!

And this is the whole point of macros: You can abstract away code idioms that you cannot astract away in any other way, and you effictively have a lot more options to change implementation details without affecting any clients.

Macros are also one of the fundamental reasons for why Lispers like Lisp's strange syntax so much: The syntax is a direct representation of what is elsewhere called the abstract syntax tree, and the fact that the AST is directly available for manipulation as a very simple list data structure makes it so straightforward and convenient to implement and use macros.

If you now have gotten the taste of this, you may want to read some more introductory material about Lisp, like my own opinionated guide, Peter Seibel's excellent book about Common Lisp, or any of the other available tutorials.

Call for Participation: ILC'07

2007-02-21T16:27:00.000+01:00

INTERNATIONAL LISP CONFERENCE 2007

Clare College, Cambridge, England - April 1-4, 2007

In cooperation with ACM SIGPLAN

Sponsored by The Association of Lisp Users

The Association of Lisp Users is pleased to announce the 2007 International Lisp Conference will be held in Cambridge, England at Clare College from April 1st to 4th, 2007. This year's program consists of tutorials at beginners' and advanced levels, prominent invited speakers from the Lisp and Scheme communities, an excellent technical session, tours of Central Cambridge, Anglesey Abbey and Ely, and a quintessential English experience: a traditional dinner served in the college's Great Hall. The advance registration deadline is March 11th. The ILC'07 programming contest is also still running until March 3rd.

Schedule

Saturday, March 31st
- Optional tour of Cambridge

Sunday, April 1st
- Tutorials and workshops
  - Ernst van Waning, Extended Tutorial: Common Lisp in One Day
  - Pascal Costanza, Context-oriented Programming in Common Lisp
  - Richard Brooksby, Improve your Lisp using the Memory Pool System
  - Duane Rettig, Optimizing and Debugging Programs in Allegro CL

Monday, April 2nd
- Invited presentations
  - Christian Queinnec, Teaching CS to undergraduates at UPMC
  - Michael Sperber, It's All about Being Right: Lessons from the R6RS Process
  - Herbert Stoyan, Lisp: Themes and History
- Presentations of accepted papers

Tuesday, April 3rd
- Invited presentations
  - Jans Aasman, Scalable Lisp Applications
  - Ralf Moeller, Building a Commercial OWL Reasoner with Lisp
  - Manuel Serrano, HOP: An Environment for Developing Web 2.0 Applications
- Presentations of accepted papers
- Annual meeting of the Association of Lisp Users
- Conference banquet

Wednesday, April 4th
- Invited presentations
  - Richard Jones, Dynamic Memory Management
  - John Mallery, Lisp/CL-HTTP
- Presentations of accepted papers

Thursday, April 5th
- Optional tour of Anglesey Abbey and Ely

Conference Registration

Conference registration is now open. The advance registration deadline is March 11th. You can get further discounts as an ACM/SIGPLAN and/or ALU member. Registration includes: access to all events, morning and afternoon teas / coffees, self-service lunch, banquet (Tuesday April 3rd), proceedings and hopefully a conference t-shirt. Accomodation is available in Clare College's "Memorial Court". Credit cards and PayPal are accepted, as are cheques (sterling or US dollars) and international bank transfers.

Organizing Committee

Co-Chairs: Carl Shapiro (SRI International), Pascal Costanza (Vrije Universiteit Brussel)

Members: Rusty Johnson (ALU), Peter Lindahl (ALU)

Program Chair: JonL White (The Ginger Ice Cream Factory / ALU)

Local chair: Nick Levine (Ravenbrook / ALU)

General correspondence: ilc07-organizing-committee at alu.org

Mailing Lists

General conference announcements are made on a very occasional basis to the low-volume mailing list ilc07-announce. If you're thinking of participating in ILC 2007, you should either join this list or take an occasional look at the archives.

Let's Lisp again!

2007-02-05T12:10:00.000+01:00

There are several news about this year's International Lisp Conference to be held in Cambridge, UK in the first week of April.

The Register has published a press release about the conference. Nick Levine told me that it's a good idea to "digg" this article (whatever that means ;). Apparently, you can do this directly via this entry at digg.

There is a conference poster available for download. Please print it off and distribute it everywhere.

Finally, you can show off your Lisp programming skills by providing implementations for the conference's programming contest.

Best Albums of 2006

2007-01-21T17:32:00.000+01:00

Here is my list of music recommendation based on what I perceived being the most interesting albums that I have listened to in 2006. This time, it is not a "best of" list, like last year, but a more careful breakdown.

First of all, the best albums that were released this year are as follows.

1. The Knife - Silent Shout.

It took me a while to get into this album. I had seen recommendations in a few places that I check every now and then, and since they are on Mute Records in the US they caught my attention. However, listening to clips of this album didn't help me at first. The first track, "Silent Shout", sounded to me like a uninspired copy of Kraftwerk, and the second one, "Neverland", like an uninspired piece of electronic punk. However, when I have seen the video clip for "We Share Our Mother's Health" in Kevin Holy's Ten Best Music Videos of 2006, I got it. I bought the album, and since then I almost exclusively listen to it. I can strongly recommend "The Captain", "We Share Our Mother's Health" and "Marble House".

2. Kate Havnevik - Melankton.

Another act from Sweden. I have listened to this a lot and considered this to be the best album of 2006 until very recently. This one is especially interesting because it is the very first album I have bought just because of a recommendation at the iTunes Music Store - I have never heard of this singer before. I can especially recommend the following tracks: "Unlike Me", "Nowhere Warm" and "Suckerlove".

3. Motor - Klunk.

I have already discussed this album before. They have supported Nitzer Ebb on their reunion tour, and Motor have been fabulous.

4. Lou Rhodes - Beloved One.

The first solo album from the singer of Lamb. Recommended tracks: "Treat Her Gently", "No Re-Run" and "Beloved One".

There were also new releases Laibach ("Volk") and Tanya Tagaq (Sinaa - I haven't heard of her before, but she was mentioned at Björk's website). Both are quite interesting and impressive, but I still have to make up my mind before final judgment.

Underworld have already started the "RiverRun Project" in 2005, but I only heard about it in 2006. It is a series of mp3 files (together with comprehensive artwork) that you can buy at their website. Since these are not commercially released on CD, they are quite free-form, which is good. I can especially recommend Lovely Broken Thing, which is part 1 in that series.

Apart from these albums, I have finally managed to get a better overview of Swans. Love of Life has always been one of my favorite albums for about ten years now, but I never took the time to take a look at their other releases (which are quite numerous). I have now listened to quite a few of their albums during this year, and I can recommend Children of God / World of Skin as a good starting point because it captures the different musical styles of Swans quite well.

Two good "best of" collections that were released in 2006 are Collected by Massive Attack and "Body of Work" by Nitzer Ebb. Apart from that, I currently listen to Tekel, who capture the sensibilities of 80's electronic pop music quite well.

That's it for now. Looking forward to new releases by Skinny Puppy, Komputer, Nine Inch Nails and Recoil in 2007...

International Lisp Conference '07 - Call for Papers

2006-10-22T14:55:00.000+02:00

The call for papers for the International Lisp Conference 2007 is out. Please consider submitting papers about all Lisp- or Scheme-related topics. This time, the conference will be in Cambridge / UK in the first week of April 2007.

Freely downloadable books by Niklaus Wirth.

2006-09-20T21:24:00.001+02:00

I haven't been aware of the fact that quite a few books by Niklaus Wirth are available as free downloads by now. Among them are such classics as Programming in Modula-2, Algorithms and Data Structures, Compiler Construction, and Project Oberon, all of them either originally in/about Oberon, or adapted to Oberon.

These books have influenced me a lot. Niklaus Wirth's main strength is a focus on the essentials, which is especially apparent in his concise programming style. I can especially recommend Compiler Construction which basically contains all you need to know about compilers in a very thin book (unless you decide to make this your field of expertise), and Project Oberon which contains the complete source code of a full operating system (including a file system, a garbage collector, a GUI, and so on).

See also the ETH Oberon Home Page for more information about Oberon and related materials.

CDR 0 & 1 finalized.

2006-09-20T20:28:00.000+02:00

The Common Lisp Document Repository (CDR) has finalized its first documents today. CDR 0 describes CDR and the CDR process itself, while CDR 1 is the CLOS MOP specification, as published as an appendix in The Art of the Metaobject Protocol by Kiczales, des Rivières and Bobrow.

These CDRs were mostly test runs of the CDR process, although they are of course also useful in their own right. (The CLOS MOP had already been published over 15 years ago and has long been proven useful, so didn't really need an official "stamp.")

See the CDR website for more information.

Furthermore, we have set up a CDR Blog where we will post CDR-related announcements - actually the same ones as in the cdr-announce mailing list.

Efficient Layer Activation for Switching Context-dependent Behavior

2006-08-24T18:24:00.000+02:00

This is a paper that I have written together with Robert Hirschfeld and Wolfgang De Meuter, and we are going to present it at the Joint Modular Languages Conference (JMLC'06) in Oxford next month. The paper discusses how the CLOS Metaobject Protocol is used to implement the features of ContextL and presents a benchmark that shows that ContextL is quite efficient - not significantly worse than CLOS, which itself can be implemented very efficiently. So context-oriented programming does not seem to place a significant burden on applications in this regard.

The benchmark is based on an example that is frequently used to discuss aspect-oriented programming, especially control-flow-related features like the cflow construct in AspectJ. In our paper, we do not use an aspect-oriented solution, but obviously one based on context-oriented programming. That solution requires repeated activations and deactivations of layers, so this is indeed a useful benchmark for ContextL. These repeated activations and deactivations do not add any significant overhead to a similar program that does not activate or deactivate layers at all. To the contrary, in CMUCL and SBCL, the runs with repeated activations / deactivations are actually faster than the ones without. This means that other factors play a more important role with regard to efficiency. The benchmark is part of the ContextL release, so you can run it in your own environment.

The paper uses a Java-style syntax instead of the original Lisp syntax. We have decided to do so to make the paper more accessible to non-Lispers. However, I will use the original ContextL version for the presentation at the conference.

The paper can be downloaded from my website.

Common Lisp Document Repository

2006-08-10T15:17:00.000+02:00

CDR - The Common Lisp Document Repository

What?

The Common Lisp Document Repository is a repository of documents that are of interest to the Common Lisp community. The most important property of a CDR document is that it will never change: if you refer to it, you can be sure that your reference will always refer to exactly the same document.

Why?

There have been a number of attempts to establish a standardization process for Common Lisp after it has been officially published as an ANSI standard. The ANSI standardization was very costly and very time consuming (according to http://groups.google.com/group/comp.lang.lisp/msg/15248a1b11c5a603 it took nearly 10 years and at least $400K).

The goal of the Common Lisp Document Repository is to be more light-weight and more efficient. We focus on one aspect of standardization: the ability to refer to a specification document in an unambiguous way.

The Common Lisp Document Repository intentionally does not define a process for coming up with specifications or any other means to guarantee some level of quality of the submitted documents. Instead, we aim for a community-driven, decentralized approach to come up, discuss and finalize specifications. In this sense, we only provide the services of librarians.

We hope that the Common Lisp Document Repository has the potential to prove useful in establishing new de-facto standards, and to serve as a stepping stone for more formal standardizations in the long run.

Where?

The Common Lisp Document Repository is hosted at http://cdr.eurolisp.org

How?

The Common Lisp Document Repository is a repository of printable text documents that contain material that are of interest to the Common Lisp community. For example, a CDR document can contain specifications of libraries, language extensions, example implementations, test suites, articles, etc. Each CDR document will be identified by a number. Form and possible contents of CDR documents are not prescribed, but the goal is to provide the Common Lisp community with a way to unambiguously refer to a document by way of mentioning its CDR number.

The repository already contains two CDR documents: CDR 0 describes CDR itself, and CDR 1 is the CLOS Metaobject Protocol specification as published in the book "The Art of the Metaobject" by Gregor Kiczales, Jim des Rivieres and Daniel G. Bobrow.

The presence of a document in the CDR repository does not imply a recommendation of any kind, but we leave the acceptance or rejection of particular documents to the community's natural selection process. We expect that some CDR documents will claim to be replacements of, or clarifications for, previous ones, but again such statements do not mean that this repository's goal is to enforce such developments. We are just librarians who want to make it possible to refer and cite documents of interest to Common Lispers.

We use a light-weight process that consists of the following steps:

One or more authors submit a document.
We check that the document is a printable text document, that it is indeed about Common Lisp, and that it does not contain objectionable material (like porn, religious or political statements, etc.).
The document will be immediately assigned a fresh CDR number that can be used to refer to the document. We will make the document available for an initial period, after which it will be frozen and moved into final status, unless the authors decide to withdraw the document during the initial period.

For more details about the process, see the CDR manual at http://cdr.eurolisp.org

The CDR editors
Marc Battyani, Pascal Costanza, Arthur Lemmens, Edi Weitz

Music recommendations May 2006

2006-05-21T14:01:00.000+02:00

I am listening a lot to the following recent releases a lot, which I hereby recommend.

Circlesquare, Fight Sounds EP. This is from Canada, and the music is somewhat like an ambient version of Nine Inch Nails. You can see a video clip for the title track at the Circlesquare website to get an impression.
Motor, Klunk. Techno with some dark edge. The reason is that one of the members has previously been with Industrial projects Hellbent and Haloblack, and the influence is clearly there. See the video for the current single and check out their website.
Ministry, Rio Grande Blood. This time they have gone metal. ;) You can listen to clips from the new album at the Ministry Online Store. (See the link above the album cover.)

Call for Participation: 3rd European Lisp Workshop

2006-05-21T13:32:00.000+02:00

The 3rd European Lisp Workshop will be held on July 3 in Nantes, France, as part of this year's European Conference on Object-Oriented Programming (ECOOP 2006). We have accepted five papers for presentation, about an agent-based framework to simulate metabolic processes, simulation of quantum computations, Lisp tools for musicology, naturalising foreign libraries, and beating C in scientific computing applications, as well as a breakout group on Lisp Hardware revisited.

Nick Levine will be giving a keynote presentation on How to stay poor, with macros and closures. He has been a professional Lisp consultant for over two decades and is the organizer of the upcoming International Lisp Conference 2007 in Cambridge, UK. We are grateful to Ravenbrook Limited for sponsoring the keynote presentation.

The workshop will also contain tutorials about CLIM and/or reflection and metaprogramming in Lisp.

There is still enough for additional participants, so please contact me if you wish to participate. Note that the early registration deadline is May 23, 2006.

See the workshop website for more detailed information.

Edit-time MOP

2006-03-25T14:06:00.000+01:00

Last week I have attended the AOSD'06 conference in my old hometown in Bonn - it was nice to be back there for a week, meet some friends, go to some favorite places of mine, especially Cafe Göttlich, and at the same time do some work. I have found one of the presentations I have seen especially intriguing, about a first implementation of an edit-time metaobject protocol. Unfortunately, it is implemented in the wrong language. ;) I think this could be a worthwhile project to implement in Lisp or Scheme.

3rd European Lisp Workshop registration fees

2006-03-18T15:04:00.000+01:00

Apart from the previous news that the 3rd European Lisp Workshop will have a best-paper award and a keynote presentation by Nick Levine, we now also have information about the registration fees. If you want to attend only the European Lisp Workshop (two days), this will cost 150 Euro for students and 250 Euro for regular participants. If you want to attend the whole conference, including the workshop, this will cost 300 Euro for students and 500 Euro for regular participants. During the workshop days, coffee breaks and lunches are included in those fees, as are receptions on both evenings that typically include food and drinks. Note that these fees are early registration fees valid only before May 23, 2006. See the conference's page about registration fees for more information.

News for the 3rd European Lisp Workshop

2006-03-14T22:59:00.000+01:00

There two news items concerning the 3rd European Lisp Workshop:

Nick Levine will be giving a keynote presentation at the European Lisp Workshop. He has been a professional Lisp consultant for over two decades and is the organizer of the upcoming International Lisp Conference 2007 in Cambridge, UK. We are grateful to Ravenbrook Limited for sponsoring the keynote presentation.
The Association of Lisp Users has kindly sponsored a $500 prize fund for exceptional papers submitted to this year's European Lisp Workshop. Both the ALU and the workshop organizers are looking forward to your submissions.

Dynamic Languages Day Material

2006-03-07T13:32:00.000+01:00

The presentations, some demo code and quicktime movies of the Dynamic Languages Day @ Vrije Universiteit Brussel are now available for download at the DLD website. Since the quicktime movies are quite large, we welcome any volunteers who want to mirror them. Please send me links that I can mention on the DLD website.

3rd European Lisp Workshop

2006-02-23T20:56:00.000+01:00

We are organizing another instance of the European Lisp Workshop (former European Lisp and Scheme Workshop). This time it will be in Nantes, Frances, on July 3 & 4, and will again be co-located with ECOOP, as in previous years. This time, the workshop is organized by Theo D'Hondt, Arthur Lemmens, Christophe Rhodes and myself. See the ELW'06 website for further information.

Workshop on Generic Programming 2006

2006-02-12T17:42:00.000+01:00

I am a member of the program committee of the forthcoming Workshop on Generic Programming 2006 at the International Conference on Functional Programming.

Closer Project: New Releases

2006-01-19T22:55:00.000+01:00

Today, I have released new versions of all the packages currently included in the Closer Project. This project is an umbrella project for a few subprojects whose aim is to improve the usability of the CLOS MOP across different Common Lisp implementations. It is also the home of ContextL, a full-fledged CLOS extension in its own right providing language constructs for Context-oriented Programming (COP).

All packages now support the current versions of all supported Common Lisp implementations. They are:

Allegro Common Lisp 7.0 Enterprise Edition.
Allegro Common Lisp 8.0 Enterprise Edition.
CLisp 2.35 - 2.37
CMU Common Lisp 19c
LispWorks 4.4.5, 4.4.6 for Macintosh, Personal Edition
LispWorks 4.4.5, 4.4.6 for Macintosh, Professional Edition
Macintosh Common Lisp 5.1
OpenMCL 1.0
SBCL 0.9.7, 0.9.8

Highlights of the new versions.

MOP Feature Tests 0.4:

All previous known but untested problems have either been resolved or turned into actual tests.
Added a test for checking whether the slot order requested by a primary method for COMPUTE-SLOTS is honored by a MOP. (Thanks to Christophe Rhodes for the suggestion.)
Added a test for checking whether the object returend by COMPUTE-DISCRIMINATING-FUNCTION can be funcalled and whether the second parameter to SET-FUNCALLABLE-INSTANCE-FUNCTION can be a 'real' closure.
Added a test for checking whether one can use one's own :ALLOCATION kinds.
Added a test for checking whether a generic function without any methods defined can still be called.
Added a test for checking whether a DEFMETHOD form can have multiple qualifiers.
Added more fine-grained tests for checking SLOT-XXX-USING-CLASS functions.
Added a test whether REINITIALIZE-INSTANCE on a class metaobject calls FINALIZE-INHERITANCE. Luckily, all implementations pass that test.

Closer to MOP 0.3:

The supported Common Lisp implementations improved with regard to their support for the MOP, with varying extent. This required a few changes here and there.
The lack of extensible :ALLOCATION kinds in Allegro Common Lisp, as specified in AMOP, is fixed. Thanks to John Foderaro for giving me the important hint on how to solve this.

ContextL 0.2:

When rebinding special places, it is now checked whether they actually contain special symbols, so this is now a safe operation. This can be tweaked to omit the check for improved performance.
Changing a non-special slot to a special slot in an already existing class is now also supported in Allegro Common Lisp from 7.0 on. Thanks to Duane Rettig for fixing the related bug in Allegro and thereby enabling this feature.
Improved parsing of layered methods: The :METHOD option in DEFINE-LAYERED-FUNCTION is now parsed and processed correctly. Furthermore, one can now optionally give a name to the otherwise anonymous layer parameter. This is useful for calling CALL-NEXT-METHOD with changed parameters.
Added a new namespace for layers. Before, their names could accidentally clash with class names.
Added a number of performance tweaks and better error messages.
Fixed a few bugs.

Special thanks go to John Foderaro, Duane Rettig and Christophe Rhodes (in alphabetical order) for exceptional help.

Dynamic Languages Day @ Vrije Universiteit Brussel

2006-01-12T20:47:00.000+01:00

On Monday, February 12 there will be a Dynamic Languages Day @ Vrije Universiteit Brussel. It will consist of a number of talks about dynamic languages. It begins with a presentation about how Scheme is used at the Vrije Universiteit Brussel as an introductory programming language, and will be followed by presentations about Self, Smalltalk and Common Lisp. A special focus will be on the reflective and metaobject features of the respective languages. I will contribute to this event by repeating my tutorial on generic functions and the CLOS Metaobject Protocol that I have already given at OOPSLA'05 and several other past events. Attendance is free and open for the general public. See the website for that event for more information.

Gekido Party 01/06

2006-01-09T13:05:00.000+01:00

This week's Saturday, I'll be going to the Gekido Party, which is one of the coolest parties around, pretty good music. And that's not just because the organizers and DJs are friends of mine. ;)

Here is a picture from last November's Gekido Party. It shows Steffi Schmid, one of my absolutely best friends of all time, and myself.

Happy new year!

2006-01-04T13:09:00.000+01:00

A Pythonista likes SLIME, the Superior Lisp Interaction Mode for Emacs. And Paul Graham prefers to write essays instead of working on something more important. ;)

ContextL in the media

2005-12-27T14:20:00.000+01:00

Bill Clementson has posted a quicktime movie of a presentation about Lisp on Lines by Drew Crampsie. It's a web application framework written in Common Lisp that takes advantage of a number of libraries, including our own ContextL.

MoDELS 2006

2005-12-22T20:45:00.000+01:00

I am a member of the program committee of MoDELS 2006 - a conference that was previously centered around UML and related technologies, but they are trying to open up. I have talked to the program chair, and he convinced me that he is very serious about this. I have also suggested to explicitly add metaprogramming to the list of topics, and it's in. So this definitely has the potential to become an interesting conference.

Best Albums of 2005

2005-12-21T22:10:00.000+01:00

OK, this is my first blog posting. In order to tell you something that makes a little sense, I list what I consider to be the best albums of 2005. The year is not over yet, but we're pretty close, so I think that's ok. So let's start:

1. Depeche Mode - Playing the Angel

Depeche Mode is one of my all-time favorite bands. Their last album "Exciter" was somewhat weak in retrospect, for example weaker than "Ultra", because it had a number of fillers that are definitely not among their best songs. I think this time they have managed to produce an album that can be considered to be among their best. It took a time to grow on me, but that's typically a good sign. It's surprising that Dave Gahan's songs are among the best ones on this album, especially "Suffer Well" and "Nothing's Impossible". Another favorite is "The Darkest Star".

2. Rasputina - A Radical Recital

Another long-time favorite. I don't remember how I discovered Rasputina about almost ten year's ago. As far as I know, their records have never been officially released in Europe, so it was definitely a bit of an accident. This one is a live album, and a kind of "best of". I would love to see them live at least just once, it must be a great experience. Favorite songs on this album: "Rose K." and "A Quitter".

3. Paula - Ruhig Blut

This is a German band. Previously, they have made purely electronic music, a mixture between OMD, Erasure and Marianne Rosenberg (because of the very high voice of the female lead singer). Now they have switched to guitars and real drums, a combination that is currently very popular in Germany, but it works surprisingly well for me here. The lyrics are great. All the songs are very good, but maybe you can try "Ruhig Blut" and "Lied für Dich".

4. Wir sind Helden - Von hier an blind

Another German band which is actually quite popular in Germany, and they actually use that popular combination of new-wavish guitars. The previous album mixed this with some Electroclash elements, but here the electronic elements are more in the background. Recommended titles: "Echolot" and "Nur ein Wort". The single "Gekommen um zu bleiben" is actually the worst track in my opinion.

5. Nine Inch Nails - With Teeth

Nine Inch Nails have finally made a relatively straightforward album. In the past, they have always put a lot of work into new sounds and complex song structures, and therefore it always took them a lot of time to release anything. But it was always worth it. "The Fragile" is an excellent album. Apparently, they don't have that energy anymore - I recall reading an interview with Trent Reznor in which he acknowledged this. Nevertheless, "With Teeth" is still better than lots of other music that is being produced, and I really enjoy listening to it. In the beginning, I didn't like "The Hand That Feeds" at all, but I even enjoy that one by now. Other recommended songs: "All the Love in the World" and "Only".

6. Ministry - Rantology

This is a party album, containing the best songs of Ministry (only the industrial metal stuff) from their back catalogue in remixed versions. Only the live material (the last three tracks) wasn't really necessary. This is not an essential record, but great fun. The new versions don't add anything really interesting, but it's great to listen to the tracks in one row. The one completely new song is probably my most favorite track of 2005, called "The Great Satan". Also great: "Unsing (Alternate Mix)"

7. Kate Bush - Aerial

Great album, although a slight bit too esoteric for my taste. "King of the Mountain" is a great track and a great single. "Bertie" and "Mrs. Bartolozzi" get on my nerves, though.

8. Daft Punk - Human After All

One of the most intelligent and funny examples of deconstructed house music. It's hard to describe. For example, "The Prime Time of Your Life" has almost all the necessary ingredients to be a party/disco hit (which would actually repel me because I normally don't like such kind of music), but it completely (and intentionally) misses the important points. It's clear what it should have been, but I'm glad that it's not. ;) "Robot Rock" takes a 70's rock sample ("Eye of the Tiger", I think), repeats it to death, but always skips the second half. Again, you know that it should be there, but they intentionally have left it incomplete. What a joy! ;)

9. Autechre - Untilted

"Intelligent" techno at its best, and they keep getting better and better. Try "LCC" and "Fermium".

10. The Chemical Brothers - Push the Button

I was much more excited when it came out, but now it's just good. They make great music, but something just doesn't stick. Hmm...

11. Mu - Out of Breach (Manchester's Revenge)

A new discovery. Weird electroclash - even weirder than typical electroclash. Try "Out of Breach" (excellent!) and "Paris Hilton" (the song, that is ;).

OK, that's it for the moment...