November 08, 2010
June 14, 2010
AOSD'11 conference
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.
June 07, 2010
International Lisp Conference '10
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.
April 25, 2010
Lisp Machine demonstration...
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...
April 13, 2010
3rd European Lisp Symposium is very soon!
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.
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:
Social events
Programme Chair
Christophe Rhodes, Goldsmiths, University of London, UK
Local Chair
Antonio Leitao, Technical University of Lisbon, Portugal
Programme Committee
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.
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.
December 04, 2009
Filtered functions
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 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:
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.
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.
It is now straightforward to use stack-state in a filter named :state for the typical stack operations.
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.)
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.
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.
April 25, 2009
European Lisp Symposium 2009 - programme details!
On May 27-29, there will be the 2nd European Lisp Symposium taking place in Milan, Italy. The program looks very exciting, and I will definitely be there (well, due to obvious reasons, see below ;).
For example, there are two keynote talks. One is by Kent Pitman who is an award-winning author of technical papers about Lisp, editor of the ANSI Common Lisp specification, and designer of the HyperSpec, the de-facto standard manual for Common Lisp. He will discuss how the Lisp community should move forward from his perspective. Kent's ideas are always well thought-out, although at times controversial, so this is certainly going to be a provocative talk.
The other is by João Pavão Martins and Ernesto Morgado, the two owners of SISCOG - a Portuguese company that develops large-scale industrial planning and scheduling software which is in use for over twenty years. It's always good to hear what practitioners have to tell about their experiences with Lisp, so this should turn out quite interesting.
There will be a couple of presentations in the main track of the symposium about papers that have been reviewed by a program committee chaired by António Leitão.
Jim Newton is going to present a type inferencing approach for the Skill dialect of Lisp that is actually being used in his group at Cadence Design Systems, one of the world-wide largest providers of Eletronic Design Automation. (If you use an eletronic device, it's very likely that the chips inside were designed using one of their tools!)
Thomas Burdick is going to present an approach for compiling FEXPRs (think: first-class macros that you can pass around like regular functions). I'm a bit skeptical here that this will work, because it is actually known that FEXPRs cannot be compiled, but maybe he has found an interesting twist to the problem.
Some colleagues of mine from the Artificial Intelligence Lab of the Vrije Universiteit Brussel in Belgium are going to present a debugging technique they have devolped for their own large-scale agent system that they use to investigate the possible development of natural languages by reconstructing how they could have evolved from simple, first-class principles. The debugging approach consists of monitoring the activities of the agents and presenting the process as an interactive webpage that can present arbitrary detailed (or abstract) views on what is happening. Very cool stuff here, and since they use web technology here, it is actually portable...
Charlotte Herzeel is going to present an architecture for Software Transactional Memory (STM). STM has become quite a hot topic in the last few years because it seems a very promising approach for dealing with concurrency, and since multicore processors are the buzz of the moment, there is a lot of interesting in such approaches. However, little attention has been payed to the design of STM frameworks where you can selectively plug in different STM algorithms. Charlotte has developed a reflective approach (think: metaobject protocol) for STM, which seems very promising (but I'm one of the co-authors of the paper, so I'm naturally biased, of course ;).
Another presentation will be about Linda-style distribution layer on top of Kenzo, an apparently very powerful system for symbolic computation developed in Common Lisp. The Linda Model (also used in JavaSpaces and TSpaces, for example) has a number of very interesting properties for distributed computing, and the paper presents an implementation based on AllegroCache, a robust and high-performance object-oriented database for Allegro Common Lisp. I'm wondering what the concrete benefits for a symbolic algebra system are, so this is another presentation to look forward to.
Finally, I am going to present a paper myself - that's the main reason why I will definitely be there ;). My presentation will be about a macro system on top of Common Lisp's macros that allows writing hygienic macros. The system provides facilities similar to Clinger's renaming construct. The interesting part is that my system is implemented in fully portable Common Lisp and integrated in such a way that 'regular' Common Lisp macros and the macros developed with this new macro system can be used together. The reason why this works is because of the use of symbol macros in the implementation of the new constructs.
Other items on the programme for the symposium are:
A debate on expanding and updating the Common Lisp standard. I am known to be quite conservative when it comes to this topic, in that I don't think ANSI Common Lisp needs a serious revision, but can be developed in a piecemeal fashion (and this actually already happens due to the efforts of the currently very vibrant Common Lisp community). I believe (obviously) that something like CDR is much more promising than a "big bang" revision of the core language. The recent developments in the Scheme community, where the highly controversial R6RS specification was almost not ratified, seems to indicate that the danger is too high that a lot of time and resources could be wasted that can otherwise be used in a much more productive way. Well, maybe there will be some new ideas and visions coming out of the debate...
On the Saturday after the symposium, there will be a visit to the Futurism exhibit in Milan. Futurism was an art movement in Italy in the early 20th century, whose founders announced that everything "old" (so artistic and political tradition) should be replaced by the new ideas of a then young generation. This is probably one of the strangest choices for the social programme of a Lisp-related event: Lisp is second oldest programming language still in use today, and has always been in competition with whatever other programming language came along that was considered to be 'newer' (as if that automically meant 'better'). However, judging for example from this blog posting, this could actually be a very inspiring exhibition.
So all in all, a highly interesting programme, with some more items being added in the coming days. (There are rumours that Christophe Rhodes is going to give a tutorial about non-portable features of SBCL, for example!) Although the early registration deadline is ending very soon now, there is no reason to despair: With €80 for students and €160 for regular participants, the registration fees will remain very low.
So, hope to see you in Milan!
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!
March 30, 2009
Credo
It has been suggested that certain programming language constructs, in particular the GO TO, lend themselves to obscure coding practices. Some language designers have even gone so far as to design languages which purposely omit such familiar constructs as GO TO in an attempt to constrain the programmer to refrain from particular styles of programming thought by the language designer to be "bad" in some sense. But any language with function calls, functional values, conditionals, correct handling of tail-recursions, and lexical scoping can simulate such "non-structured" constructs as GO TO statements, call-by-name, and fluid variables in a straightforward manner. If the language also has a macro processor or preprocessor, these simulations will even be convenient to use.
No amount of language design can force a programmer to write clear programs. If the programmer's conception of the problem is badly organized, then his program will also be badly organized. The extent to which a programming language can help a programmer to organize his problem is precisely the extent to which it provides features appropriate to his problem domain. The emphasis should not be on eliminating "bad" language constructs, but on discovering or inventing helpful ones.
Guy L. Steele Jr. and Gerald J. Sussman
Lambda - The Ultimate Imperative
March 12, 2009
Lisp: Research and Experience
In the last couple of years, we have seen a growing interest in the Lisp programming language and its various dialects, including classic ones, like Common Lisp and Scheme, and also brand new ones, like Clojure and Qi. Several user group meetings, workshops and conferences have been organized with great success in recent years, especially in Europe, but also elsewhere.
With the European Lisp Symposium, we aim to start a series of annual events that is especially suitable for novel research results, but also for insights and lessons learned from practical applications and education perspectives, all involving Lisp dialects. The first symposium was organized in Bordeaux, France, on May 22 and 23, 2008.
For this symposium, we have received 15 submissions, and after a careful review process, the program committee selected seven of them for presentation at the main track of the symposium. The program committee considered six of these papers worthy of being invited for a journal publication. Their authors submitted extended versions of these papers, and after another thorough review process with additional reviewers, these papers have indeed reached the necessary level of quality and maturity.
These papers are now finally published in a special issue Lisp: Research and Experience of the Journal of Universal Computer Science.
Preparations for the 2nd European Lisp Symposium to be held in Milan, Italy, May 27-29, 2009 are already under way...
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...
January 26, 2009
European Lisp Symposium 2009
There will be another instance of the European Lisp Symposium this year: in Milan, Italy, from May 27-29, 2009. It's very good that this event takes place so relatively shortly after the successful European Lisp Symposium 2008 about one year ago. Special kudos go to Marco Antoniotti for the local organization and Antonio Leitao for having assembled a great program committee.
The rates for attending the symposium are again very reasonable: Students can get in for as low as €60, and other participants for reasonable €100, when taking advantage of the early registration rates. See the registration page at the symposium website for more details.
More importantly, though: You can still submit papers to the symposium. The deadline for paper submissions is February 4, 2009, and the program committee accepts both original contributions, including research papers and experience reports, as well as descriptions of work in progress. Again, see the symposium website for more details.
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.
September 18, 2008
Lisp50@OOPSLA
...celebrating the 50th birthday of Lisp at OOPSLA 2008
Monday, October 20, 2008
Nashville, Tennessee, USA
co-located with OOPSLA 2008
participation is free for all OOPSLA participants
registration for at least one conference day at OOPSLA is required
URL: http:www.lisp50.org
Feed: http://lisp50.blogspot.com
Invited Speakers
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
Sponsored by ACM SIGPLAN
Supported by
Monday, October 20, 2008
Nashville, Tennessee, USA
co-located with OOPSLA 2008
participation is free for all OOPSLA participants
registration for at least one conference day at OOPSLA is required
URL: http:www.lisp50.org
Feed: http://lisp50.blogspot.com
Invited Speakers
- William Clinger, Northeastern University, USA
- Pascal Costanza, Vrije Universiteit Brussel, Belgium
- Richard Gabriel, IBM Research, USA
- Rich Hickey, Independent Consultant, USA
- Alan Kay, Viewpoints Research Institute, USA
- Fritz Kunze, USA
- Ora Lassila, Nokia Research Center, USA
- John McCarthy, USA
- Kent Pitman, PTC, USA
- Guy Steele, Sun Microsystems Laboratories, USA
- Herbert Stoyan, University of Erlangen, Germany
- Warren Teitelman, Google Inc., USA
- JonL White, USA
Titles, abstracts, biographies and schedule will be announced at the
Lisp50 webpage and blog in the coming days and weeks.
Abstract
In October 1958, John McCarthy published one in a series of reports about his then ongoing effort for designing a new programming language that would be especially suited for achieving artificial intelligence. That report was the first one to use the name LISP for this new programming language. 50 years later, Lisp is still in use. This year we are celebrating Lisp's 50th birthday. OOPSLA 2008 is an excellent venue for such a celebration, because object-oriented programming benefited heavily from Lisp ideas and because OOPSLA 2008 takes place in October, exactly 50 years after the name Lisp has been used publicly for the first time. We will have talks by John McCarthy himself, and numerous other influential Lispers from the past five decades. We will also take a look at the next 50 years of Lisp.
Organizers
- Pascal Costanza, Vrije Universiteit Brussel, Belgium
- Richard Gabriel, IBM Research, Hawthorne, NY, USA
- Robert Hirschfeld, Hasso-Plattner-Institut, Potsdam, Germany
- Guy Steele, Sun Microsystems Laboratories, Burlington, MA, USA
Sponsored by ACM SIGPLAN
Supported by
September 14, 2008
Reflection for the Masses
Programming languages provide more or less narrow models on how solutions should be represented and thought about, and enforce such models in more or less strict ways. However, it always happens that the offered models are not completely appropriate, but need to be adapted in some ways to better fit a concrete problem at hand. Design patterns and programming styles provide ways to deal with such situations: By applying some principles in your code, you can work around limitations of a programming language and/or benefit from properties that arise from such principles. For example, it is then possible to replace algorithms at runtime in an otherwise static language, take advantage of a "pure" functions in an otherwise imperative language, and so on.
Reflection is a more systematic way to open up a programming language and extend it beyond the designer's original intent. By exposing internal implementation details of the language to programmers, they can add and modify features of the language in a principled way. For example, metaobject protocols are prime examples of reflection in programming languages.
Reflection is one of the corner stones of programming languages: Many programming languages provide some form of reflection, and certainly almost all of the widely used ones. So there seem to be clear benefits from being able to inspect and extend languages from within themselves.
The first dedicated account of reflection was provided by Brian C. Smith at the beginning of the 1980's, and he used his own dialect called 3-Lisp as a way to illustrate the principles behind reflection, especially for procedural, but also for structural reflection. (Instead of "procedural reflection," we would nowadays say "behavioral reflection.") Unfortunately, Smith's papers and PhD thesis are very hard to follow and understand: Since he is primarily a philosopher, and not a computer scientist, he uses terminology borrowed from philosophy, and on top of that, takes concepts from Lisp dialects of his time for granted that even seasoned modern Lispers do not fully grasp anymore.
In a recent attempt to better understand the ideas and concepts behind Smith's account of reflection and 3-Lisp, Charlotte Herzeel and myself carefully studied Smith's papers and the follow-up literature that directly referred to Smith's work in detail. Eventually, Charlotte reimplemented 3-Lisp in Common Lisp, and we discussed several aspects of that implementation from various perspectives. In the end, we were both surprised how well thought out Smith's conceptualization is even with regard to lots of details you have to face when actually implementing reflection - details that many of the follow-up authors in their own accounts seemed to have missed. However, we are also convinced that Smith made some "mistakes" - especially, we are now convinced that the model of an "infinite reflective tower" is at best a neat theoretical setup, but not at all useful for practical purposes.
Our work culminated in a paper called "Reflection for the Masses," co-authored with Theo D'Hondt, which Charlotte presented at this year's Workshop on Self-sustaining Systems (S3) in Potsdam, Germany. The paper is now also available on my website. It discusses Charlotte's implementation of 3-Lisp in detail and explains the concepts and details of reflection as we see them. It also contains the full implementation of 3-Lisp in Common Lisp as an appendix.
We are very proud of that paper. We think that we achieved a major step forward in better explaining reflection to a more general audience. It is still a presentation that is probably a lot easier to understand for Lispers, and probably quite hard to follow for non-Lispers, but we removed a lot of Smith's obscurities in his original presentation and are convinced that especially Common Lispers should be able to easily understand and enjoy our version.
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.
June 01, 2008
New versions of Closer libraries released
I have just released new versions of all Closer libraries, including Closer to MOP and ContextL.
A major change that affects all libraries is that I have dropped support for Macintosh Common Lisp, and "replaced" OpenMCL with Clozure Common Lisp. Furthermore, the dependency of Closer to MOP to LW-Compat has been removed due to requests by users, but a dependency of ContextL to the portable-threads librarie of the GBBopen project has been added.
Other highlights include:
Closer to MOP 0.5
ContextL 0.5
MOP Feature Tests 0.45
The libraries can be downloaded from the Closer Project and are asdf-installable, as usual.
A major change that affects all libraries is that I have dropped support for Macintosh Common Lisp, and "replaced" OpenMCL with Clozure Common Lisp. Furthermore, the dependency of Closer to MOP to LW-Compat has been removed due to requests by users, but a dependency of ContextL to the portable-threads librarie of the GBBopen project has been added.
Other highlights include:
Closer to MOP 0.5
- In MCL, OpenMCL and Clozure Common Lisp, funcallable-standard-object is now exported from Closer to MOP.
- Fixed the lack of :generic-function-argument-precedence-order-returns-required-arguments in Allegro Common Lisp.
- Ensured that a defgeneric form makes a generic function metaobject available in the compile-time environment. Otherwise, defmethod may not yield a method of the correct method metaobject class.
- Added support for compute-discriminating-function in Clozure Common Lisp and OpenMCL, based on code provided by Slava Akhmechet.
- Added a classp predicate (due to Willem Broekema).
ContextL 0.5
- Added :in as an alternative for :in-layer in the various define-layered-xyz macros.
- ContextL now depends on portable-threads of the GBBopen project. This is done for locking critical sections to ensure thread safety of ContextL.
- Added new functions active-layers and (setf current-layer-context).
- Added a garbage collector for layer caches, such that redefinition of layers or certain methods in the ContextL MOP have an effect.
- Simplified mapping of layer-related names to internal names, which should also make things easier to read when debugging ContextL programs.
MOP Feature Tests 0.45
- Added new recognized standard feature :generic-function-argument-precedence-order-returns-required-arguments.
- Added a new known extra feature for SBCL (since SBCL version 1.0.14).
The libraries can be downloaded from the Closer Project and are asdf-installable, as usual.
Reengineering Patterns
Most people misunderstand the concept of patterns. This is probably mostly due to the Design Patterns book by Gamma, Helm, Johnson and Vlissides, which only conveys parts of what patterns can actually express and what they can be used for. People who know "better" languages know that most of the design patterns in that book can be much easier expressed, such that they virtually go away. However, that's not the "fault" of the patterns concept, that's rather a problem with that book, in that quite boring patterns have been selected.
A much better book is "Object-Oriented Reengineering Patterns" by Demeyer, Ducasse and Nierstrasz. In my opinion, it is probably the best book about (software-related) patterns that has been published so far. The good news is that the book is now freely available for download, so check it out.
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.
May 27, 2008
ELS'08 Report
Last week, the 1st European Lisp Symposium took place in Bordeaux, France. It was a very successful event, with some excellent paper presentations, but also more interactive formats. For example, we tried out the writers' workshop format for what we called a "work-in-progress" track, which was pretty well received by the participating authors. It's a format that focuses on improving the quality of papers that are not yet ready for publication. I'm very optimistic that we will see the results of this track at future Lisp events. We also organized "birds of a feather" sessions on various topics (distributed programming, image processing, CLIM and better system definition facilities), which were also very well received by the participants. It is my hope that future Lisp events will have more of these interactive formats.
The symposium itself went very smoothly, which was primarily due to the excellent local organization by Antoine Allombert, Marie Beurton-Aimar, Irène Durand, Nicole Lun and Robert Strandh. Without their willingness to organize the event and without the energy they put into it, the symposium would have never taken place. So a big thank you to all of them!
It was our intention to organize the European Lisp Symposium as an annual event right from the start. So the preparations for next year's ELS have already started, which will take place in Milan in 2009, at around the same time of the year (ca. end of May), and will be organized by Marco Antoniotti and António Leitão. More news will follow on the usual channels, but you can already start to prepare your ideas for ELS 2009!
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!
May 26, 2008
Fear of DSLs?
In Fear of Parsers? I responded to Martin Fowler's posting ParserFear, arguing that more often than not, building new parsers for domain-specific languages may be too complicated for the benefits you can get from using domain-specific syntax.
To be clear about this: This is not an argument against domain-specific languages in general, only against domain-specific syntax. Domain-specific languages in Lisp are straightforward to build, easy to use once you are used to Lisp (which is not that hard either), and flexible enough to be adapted to future needs, without getting into the hairy details of designing and implementing suitable domain-specific parsers.
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.
May 20, 2008
Fear of parsers?
Martin Fowler posts a lot about DSLs these days. In a recent post about ParserFear, he comments on an apparently typical reaction against creating one's own DSLs. That reaction seems to be that parsers are hard to write, and that it's easier to use XML instead because with XML, you get the parser for free. Martin Fowler then continues to explain why in his experience, parsers are not hard to implement, by contrasting a specific XML case with an alternative design using Antlr.
I think he misses the point, though. It's indeed the case that, taken by themselves, parsers are not very hard to write, especially if you stick to simple grammars. However, they could just be a too high investment for too little return.
This reminds me of a different story: A couple of years ago, Erich Gamma answered a few questions about patterns in one of his talks. One question was about which patterns he would not include anymore in the Design Patterns book. Among others, he mentioned the Singleton and the Visitor pattern, and his explanation for not including them was that he deems them too complicated.
Most people react puzzled when they hear this story. Yes, everybody who has tried to implement visitors knows that they are quite complicated, but in contrast, singletons seem extremely simple and straightforward to implement. However, the major point here is that they are too complicated for what they achieve: A singleton only guarantees that you get exactly one instance of a class, not more, not less. You might as well just introduce a global variable with that one instance and don't bother going through the minutiae of implementing the Singleton pattern correctly (which has border cases that you can get wrong after all, depending on what language you have to implement it in).
That's the major point: The effort has to be compared against the benefits you achieve. The same holds for writing parsers for DSLs. A domain-specific syntax simply doesn't buy you that much, but just creates another layer of code that needs to be maintained and can create follow-up problems, for example, when the syntax you designed happens to be too inflexible to be adapted to change requests in future versions of your code.
This is also the main reason why Lispers like s-expression. The rules for s-expressions are extremely simple, but at the same time also very flexible: The first element in a list determines the meaning of an expression, and all other elements are interpreted in terms of that first element. The same in XML: The tag determines the meaning of an expression, and everything that is nested inside it is interpreted in terms of the tag. An advantage of Lisp over XML is that you don't even need separate reading and processing steps of DOMs, since s-expressions are seamlessly embedded in the language itself.
So the main point of "parser fear" is not that parsers are hard, but just too hard for what they buy you.
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.
April 18, 2008
ELS'08: Invited talk
Details of Marco Antoniotti's keynote talk, to be presented at the 1st European Lisp Symposium 2008 in Bordeaux on May 23, 2008, are now available at the symposium website.
Registration is open - watch out for reduced fees before the early registration deadline!
Registration is open - watch out for reduced fees before the early registration deadline!
April 09, 2008
ELS'08: Programme published, registration, and more...
We have published the list of accepted papers that will be presented at the 1st European Lisp Symposium (ELS 2008) in Bordeaux/France on May 22-23. We have papers about temporal reasoning, context-oriented programming, visual programming, object-relational mappings, clim presentation types, custom specializers for object-oriented lisp, binary methods programming in CLOS.
Programme of the symposium.
We have also provided information about Bordeaux and about the social events programme accompanying the symposium. There will be a cocktail party, a dinner, and an optional excursion to the atlantic coast.
Information about Bordeaux, including how to reach Bordeaux by plane and by train.
Details about the social programme.
Registration for the symposium and for the optional excursion is open! Please take advantage of the reduced registration fees before the early registration deadline, April 25, 2008. Registering early helps us in planning the details of the symposium better. The early registration fee is 50€ for students and 120€ for regular participants.
The registration page.
You have to take care of accommodation yourself. We have provided a list of recommended hotels. For some of them, accounts for symposium participants are available.
The list of recommended hotels.
Looking forward to seeing you in Bordeaux!
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!
March 18, 2008
ELS'08 News!
Hi everybody,
Here are some news about the upcoming 1st European Lisp Symposium, that will take place in Bordeaux/France on May 22-23, 2008.
First of all, registration is now open to everybody, and you can register for the symposium and the accompanying social event at the symposium website.
There is no programme yet, because the paper submissions are currently still under review. (The programme will be announced in early April.) However, Marco Antoniotti has kindly accepted an invitation to give the keynote for the symposium. More details on his keynote talk will follow soon.
On a related note, the call for work-in-progress papers is still open. We have actually just extended the deadline to April 4, 2008 for submissions for this track. This is a great opportunity to get early feedback for your current projects from other researchers, practitioners and educators.
Finally, we have added two pages to the website about Bordeaux in general and an optional social event that you can additionally book when you register for the symposium: A whole-day visit of the atlantic coast on the Saturday immediately after the symposium, which includes a boat trip, a seafood and white wine tasting session, a lunch, and a trip to the Great Dune of Pyla, the highest sand dune in Europe. Don't forget your swimsuit, if climbing the 107 meters of the dune invites you to dive into the ocean!
More news to follow as they arrive.
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.
Subscribe to:
Posts (Atom)