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!
May 27, 2008
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.
March 08, 2008
COP in Journal of Object Technology
There is a new article about Context-oriented Programming in the Journal of Object Technology.
It discusses context-oriented extensions for Common Lisp, Smalltalk and Java, namely ContextL, ContextS and ContextJ. There is a new ContextL example presented in this article that we haven't discussed in any of the previous papers, so it should be an interesting read for ContextL users as well.
As always, please feel free to send feedback and suggestions.
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.
December 19, 2007
Origin of Advice
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:
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.
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
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:
You need RealPlayer to see this.
- Pascal Costanza, The CLOS Metaobject Protocol (in German)
- Charlotte Herzeel, Reflecting on 3-Lisp (in English)
You need RealPlayer to see this.
December 10, 2007
European Lisp Symposium mentioned in Linux Magazin
The 1st European Lisp Symposium is mentioned in Linux Magazin online (in German language).
December 06, 2007
European Lisp Symposium 2008 - Call for Papers
1st European Lisp Symposium
Bordeaux, France, May 22-23, 2008
LaBRI, Université Bordeaux 1
Important Dates
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:
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.
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
Program Committee
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
November 03, 2007
Lisp success story from Hungary
[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... ;-)
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... ;-)
September 03, 2007
ContextL Survey September 2007
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.
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.
July 26, 2007
ECOOP'07 Lisp Dinner
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.
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.
June 28, 2007
Lisp meeting in The Hague this Sunday
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
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
June 25, 2007
AMOP at Google Book Search
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
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.
Anyway, the information in that article is still valid, so I can recommend it.
June 03, 2007
Dr. Dobb's Classic Lisp Articles
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.
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.
May 17, 2007
European Lisp Workshop '07 - news
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:
See the workshop website for more information.
- 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.
April 24, 2007
ELW'07
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.
Subscribe to:
Posts (Atom)