[TYPES] SCOOL

[Michael Hicks]

If you are working on type-based solutions to concurrency problems (or 
other semantics issues involving concurrency), your submission to this 
workshop would be most welcome!
-Mike



                   Synchronization and Concurrency in

                   Object-Oriented Languages (SCOOL)


            OOPSLA 2005 Workshop, San Diego, California, USA

                        Sunday October 16, 2005



Call for papers

   As mainstream hardware moves to multicore processors, programmers
   will be forced to write multithreaded programs in order to achieve
   high performance.  One thing seems clear: mainstream programmers
   cannot use today's abstractions of locks, condition variables,
   semaphores, and barriers to develop scalable parallel software
   effectively.  This workshop addresses the problem of how best to
   express synchronization and concurrency in object-oriented
   multithreaded programming environments.

   This workshop will bring together researchers working on different
   parts of this problem, including: frameworks and libraries for
   concurrent object-oriented programming, patterns in concurrent
   software, tools for detecting concurrency-related bugs, new
   programming abstractions, and new directions for low-level support
   from the operating system and hardware.

   We hope to build on the success of last year's workshop on
   Concurrency and Synchronization in Java Programs (CSJP) to
   understand how these pieces fit together, and to define the research
   challenges that will adapt today's object-oriented programming
   languages for tomorrow's hardware.

   Papers will be selected for their intrinsic interest and timeliness
   of the work.  Authors are encouraged to submit polished descriptions
   of work in progress as well as papers describing completed projects.

   In case of queries about the workshop, please contact
   scool05 at microsoft.com.

Specific topics of interest include, but are not limited to:

   - Analysis, assurance, testing and verification techniques.
   - Case studies.
   - Compiler transformations.
   - Concurrent data structure implementations.
   - Contention management.
   - Expression of concurrency-related design intent.
   - Hard synchronization problems without adequate solutions.
   - Hardware and operating system support for concurrency abstractions.
   - Interactions between garbage collection and synchronization.
   - Languages and semantics.
   - Libraries to support concurrency, e.g., JSR166.
   - Memory models for concurrent object-oriented languages.
   - Nonblocking synchronization.
   - Performance and scalability techniques and studies.
   - Synchronization abstractions such as transactional memory and
monitors.

Paper submission:

   Accepted papers will be available online before the workshop rather
   than in printed form.  They will be placed in a permanent collection
   at the University of Rochester's online digital archive
   (http://urresearch.rochester.edu) for future citation.  Papers
   accepted to the workshop may subsequently be submitted to more
   formal publication venues if this is allowed by the rules of those
   venues. A special journal issue associated with the workshop is
   being considered.  Papers should be submitted online in PDF or
   PostScript format formatted with an 11 point font on up to 10 pages
   of US "letter" paper.  Instructions will be available from
   http://research.microsoft.com/~tharris/scool05/

Important dates:

   Submissions due: 29 July 2005
   Notification: 5 September 2005
   Revisions due: 3 October 2005
   Workshop: 16 October 2005

Co-organizers:

   Tim Harris (Microsoft Research)
   Doug Lea (State University of New York)

Program committee:

   David F. Bacon (IBM Research)
   Keir Fraser (University of Cambridge)
   Aaron Greenhouse (Software Engineering Institute, CMU)
   Bradley C. Kuszmaul (MIT)
   Maurice Herlihy (Brown University)
   Michael Hicks (University of Maryland)
   Tony Hosking (Purdue University)
   Gary Lindstrom (University of Utah)
   Victor Luchangco (Sun Microsystems Labs)
   John Potter (University of New South Wales)
   Ravi Rajwar (Intel)
   Michael L. Scott (University of Rochester)