Lambda the Ultimate

                 Call For Papers
          2009 International Workshop on
     Foundations of Object-Oriented Languages
                  (FOOL '09)

            Sponsored by ACM SIGPLAN

           Saturday, 24 January 2009
             Savannah, Georgia, USA
               Following POPL '09
                     
        http://www.cs.cmu.edu/~aldrich/FOOL09/

Deadlines
     Abstract Submission: Thursday, 9 October 2008
             (required to submit a paper)
     Paper Submissions: Monday, 13 October 2008
     Notifications: Wednesday, 26 November 2008
     Final versions: Monday, 22 December 2008

Workshop Description

The search for sound principles for object-oriented languages has given rise to much work during the past two decades, leading to a better understanding of the key concepts of object-oriented languages and to important developments in type theory, semantics, program verification, and program development. FOOL became FOOL/WOOD in 2006, joining forces with the Workshop on Object-Oriented Developments. Although last year the name returned to FOOL, it is the fourth workshop in that successful merger. FOOL'09 will be held in Savannah, Georgia, USA on Saturday, 24 January 2009, the day after POPL.

Submissions for this event are invited in the general area of foundations of object-oriented languages and program analysis. Topics of interest include language semantics, type systems, program analysis and verification, formal calculi, concurrent and distributed languages, database languages, and language-based security issues.

Papers are welcome to include formal descriptions and proofs, but these are not required; the key consideration is that papers should present novel and valuable ideas or experiences. The main focus in selecting workshop contributions will be the intrinsic interest and timeliness of the work, so authors are encouraged to submit polished descriptions of work in progress as well as papers describing completed projects.

A web page will be created and made available as an informal electronic proceedings. Historically, presentation at FOOL (or FOOL/WOOD) does not count as prior publication, and many of the results presented at FOOL have later been published at ECOOP, OOPSLA, POPL, and other conferences.

Submission Instructions

We solicit submissions on original research not previously published or currently submitted for publication elsewhere. The program chair should be informed of any related submissions; see the ACM SIGPLAN Republication Policy:

http://www.acm.org/sigs/sigplan/republicationpolicy.htm

Submissions should be PDF or PostScript in standard SIGPLAN 9pt conference format for a US-letter size page. Templates are available at

http://www.acm.org/sigs/sigplan/authorInformation.htm

While submissions can be up to 12 pages, shorter papers describing promising preliminary work are also encouraged. More detailed submission instructions will be announced on the workshop web site at "http://www.cs.cmu.edu/~aldrich/FOOL09/.

Program Chair

Jonathan Aldrich (Carnegie Mellon University)
    e-mail: jonathan.aldrich@cs.cmu.edu

Program Committee

• Viviana Bono (Università di Torino)
• Gilad Bracha (Cadence Design Systems)
• Sophia Drossopoulou (Imperial College London)
• Atsushi Igarashi (Kyoto University)
• OndÅ™ej Lhoták (University of Waterloo)
• Ole Lehrmann Madsen (Aarhus University)
• Sean McDirmid (Microsoft Advanced Technology Center)
• Peter Müller (Microsoft Research)
• Jeremy Siek (University of Colorado at Boulder)
• Mandana Vaziri (IBM Research)

Steering Committee

• Viviana Bono (Universita` di Torino)
• Kathleen Fisher (AT&T Labs)
• Atsushi Igarashi (Kyoto University)
• Benjamin Pierce (University of Pennsylvania)
• John Reppy (University of Chicago)
• Christopher Stone (Harvey Mudd College) [Chair]
• Philip Wadler (University of Edinburgh)

Predicate Dispatching: A Unified Theory of Dispatch by Michael Ernst, Craig Kaplan, and Craig Chambers, ECOOP'98 [gud-ecoop98.ps.gz] introduced the concept of predicate dispatching which

... generalizes previous method dispatch mechanisms by permitting arbitrary predicates to control method applicability and by using logical implication between predicates as the overriding relationship. The method selected to handle a message send can depend not just on the classes of the arguments, as in ordinary object-oriented dispatch, but also on the classes of subcomponents, on an argument's state, and on relationships between objects. This simple mechanism subsumes and extends object-oriented single and multiple dispatch, ML-style pattern matching, predicate classes, and classifiers, which can all be regarded as syntactic sugar for predicate dispatching.

A simple example that implements zip:

type List;
  class Cons subtypes List { head:Any, tail:List};
  class Nil subtypes List;

signature Zip(List, List): List;

method Zip(lst1, lst2) when lst1@Cons and lst2@Cons {
   return Cons(Pair(lst1.head, lst2.head),
               Zip(lst1.tail, lst2.tail)); }

method Zip(lst1, lst2) when lst1@Nil or lst2@Nil { return Nil; }

This is better than multi-methods because

... a lexicographic ordering for multimethods [Ste90] is error-prone and unnatural, and programmers are not warned of potential ambiguities. In a traditional (singly- or multiply-dispatched) object-oriented language without the ability to order cases, either the base case of Zip must be written as the default case for all pairs of List objects (unnaturally, and unsafely in the face of future additions of new subclasses of List), or three separate but identical base methods must be written: one for Nil×Any, one for Any×Nil, and a third for Nil×Nil to resolve the ambiguity between the first two. In our experience with object-oriented languages (using a pointwise, not lexicographic, ordering), these triplicate base methods for binary messages occur frequently.

A question from proggit:

"Is there a more, uh, layperson-oriented explanation of some of the concepts available? I'm trying to figure out how things work and I've got a good grasp of the simpler dependent type examples (like the second factorial function on the website) but the texts I've found assume knowledge of far too much terminology especially regarding the theorem proving and I can't really follow them."

Given what's happening in Wall Street two questions relevant to LtU come to mind: (1) We've been hearing about all kinds of uses of PLT ideas for financial instruments. Is any of the projects we heard of directly involved in the current mess (the problem is of course not due to software, software was probably used to calculate risk and design and execute financial contracts). (2) How is the current situation affecting PLT folks working for/on Wall Street?

I'd appreciate to hear from people in the know, and not idle speculation. LtU is, of course, not the place for general discussion of the financial crisis.