Just to report on work in progress: I am currently working in my spare time on making sure that Closer to MOP works (again) with ABCL and ECL. ABCL is in relatively good shape, but still needs a couple of bugs fixed here and there. Rudi Schlatte is doing a fantastic job at responding to bug reports. I'm pretty sure the next release will have excellent Closer to MOP support. ECL's recent version came with several changes in its CLOS MOP implementation which broke a lot of things in Closer to MOP, so the current version of Closer to MOP doesn't work with ECL. I'm doing what I can to make sure Closer to MOP is back to speed again with ECL. However, I can only do this in my spare time, and will be busy moving in the next couple of weeks, so some delays are to be expected...
September 25, 2012
August 09, 2012
Arguments against call/cc
An excellent collection of good arguments against having call/cc in a programming language (such as Scheme), by the ever-inspiring Oleg Kiselyow: An argument against call/cc.
May 02, 2012
Common Lisp, the Untold Story
Nice article by Kent Pitman, mostly about his experiences with the Common Lisp standardization process: Common Lisp, the Untold Story.
100% programmed in Common Lisp, the artificial intelligence applications development language
A short article about an apparently successful digital livescan fingerprinting system.
November 08, 2011
October 01, 2011
Beware the Purists...
See Beware the Purists, Lest They Kill Your Innovation. Much of what is stated there also strongly applies to programming and programming languages...
August 30, 2011
The Perils of Partially Powered Languages
Here is a worthwhile read: The Perils of Partially Powered Languages. It's from a Haskell perspective, but should apply to other non-underpowered languages as well. ;)
August 12, 2011
Complexity metrics other than code size don't mean that much...
See here. To cite:
"El Emam and his colleagues repeated some of those experiments using bivariate analysis so that they could allocate a share of the blame to code size (measured by number of lines) and the metric in question. It turned out that code size accounted for all of the significant variation: in other words, the object-oriented metrics they looked at didn’t have any actual predictive power once they normalized for the number of lines of code. Herraiz and Hassan’s chapter in Making Software, which reports on an even larger study using open source software, reached the same conclusion:
'…for non-header files written in C language, all the complexity metrics are highly correlated with lines of code, and therefore the more complex metrics provide no further information that could not be measured simply with lines of code… In our opinion, there is a clear lesson from this study: syntactic complexity metrics cannot capture the whole picture of software complexity. Complexity metrics that are exclusively based on the structure of the program or the properties of the text…do not provide information on the amount of effort that is needed to comprehend a piece of code—or, at least, no more information than lines of code do.'"
"El Emam and his colleagues repeated some of those experiments using bivariate analysis so that they could allocate a share of the blame to code size (measured by number of lines) and the metric in question. It turned out that code size accounted for all of the significant variation: in other words, the object-oriented metrics they looked at didn’t have any actual predictive power once they normalized for the number of lines of code. Herraiz and Hassan’s chapter in Making Software, which reports on an even larger study using open source software, reached the same conclusion:
'…for non-header files written in C language, all the complexity metrics are highly correlated with lines of code, and therefore the more complex metrics provide no further information that could not be measured simply with lines of code… In our opinion, there is a clear lesson from this study: syntactic complexity metrics cannot capture the whole picture of software complexity. Complexity metrics that are exclusively based on the structure of the program or the properties of the text…do not provide information on the amount of effort that is needed to comprehend a piece of code—or, at least, no more information than lines of code do.'"
February 01, 2011
Special variables in Java
Wow. This is how complicated it gets to have he functionality of special variables in a language that really doesn't want them (and it's brought to you by Google): Google Guice
December 30, 2010
A non-hierarchical approach to object-oriented programming
The Lisp historical archive web site just got reorganized. I have made a quick check of the contents, and found out that Howard I. Cannon's original technical report about Flavors - A non-hierarchical approach to object-oriented programming was finally made available as part of that archive. The report was originally written in 1979, was circulated around Lispers, but was never ever published as an actual technical report, although it is cited as such in several later papers by other authors. It describes the original object-oriented extension to the MIT Lisp Machine, heavily influenced by Smalltalk, but with multiple inheritance and method combinations added (but no multiple dispatch yet, which got only introduced in CommonLoops, a direct predecessor of CLOS). Although unpublished and clearly in an unfinished state, this report itself influenced a lot of other subsequent experiments with object-oriented extensions to Lisp dialects. Among other things, it already mentions the idea of exploring "meta-protocols" for making parts of the implementation of the object-oriented extension itself customizable, which was later investigated in much more detail as part of the work on the CLOS MOP (see also The Art of the Metaobject Protocol). And, of course, method combinations were already a very early predecessor of aspect-oriented programming.
It's good that this very important historical document is finally available!
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.
Subscribe to:
Posts (Atom)