Call For Participation

SPLASH 2010 Workshop on
Concurrency for the Application Programmer

Monday, October 18, 2010
Splash, Reno Nevada

For more information and discussion about this workshop, join the CAP Facebook group.

Forced by architectural and commercial considerations, programmers now have to confront multi-core systems, heterogeneity, clusters, clouds.

What does this revolution mean for the application programmer, typically removed from the hardware through many layers of middle-ware (often on top of managed run-time environments)? How should the capabilities of heterogeneous processors (including GPUs, FPGAs, streaming processors) and heterogeneous memory (including non-coherent memory) be made available to the application programmer? Should abstractions for the application programmer focus primarily on application-level concurrency rather than implementation-level concurrency? Should application-level concurrency abstractions be fundamentally determinate? Fundamentally declarative? Resilient in the face of node- and network- failure? How can high-performance concurrent programs be written in garbage-collected languages? How can they not be written in garbage-collected languages?

This workshop aims to bring together practitioners and thinkers to address all topics around concurrency for the application programmer. We intend to try to keep the workshop small (ideally, between 20 - 40 participants). Participants are expected to have significant experience developing either applications, or concurrent application frameworks (e.g. Hadoop, data-streaming languages) or domain-specific languages, or tooling for application programmers.

Potential participants are requested to submit either 10-page technical papers or 3-page position papers, using 10-point ACM SIGPLAN templates to The Program Committee will choose from the selected submissions. Participation in the workshop will be through invitations and on the basis of submissions.

Tentative Program

After the keynote, the workshop will target three main topics that arise in the support of concurrency for application programmers. Each session will start out with brief (approximately 10 minute) presentations based in part on submitted papers, but focusing on relevance to the session theme. The presenters will then moderate discussions aimed to reach conclusions about the questions and issues at hand. Other attendees are encouraged to prepare a slide or two beforehand in support of positions offered during these discussions. If possible, please tell the chairs in advance that you plan to do this.

Updates to some of the papers listed below are forthcoming.

Session 1 (8:30 - 10:00) - Keynote

Joint session with EVALUATE 2010 keynote by Cliff Click. (Please check room number at Splash.)

Session 2 (10:30 - noon) - Convergence

One impediment to supporting concurrency is the existence of multiple programming models for parallel programming. Historically, these have also been associated with different languages, runtimes/VMs, library APIs, and tools. These differences may be accentuated with the advent of special-purpose parallel hardware support such as GPUs and hybrid processors. Can and should we seek convergence across these different approaches? Sample issues include language and environment support for specialization, multitasking versus dedicated assignment, resource management and garbage collection.


Session 3 (1:30 - 3:00) - Parallelization

Languages, runtimes, libraries, tools, and engineering processes should make it easy to exploit parallelism, even, or especially by developers with little background in parallel computing. Is it worthwhile to implicitly parallelize code that is written in purely sequential form? How much or little support is needed for programmers to {minimally, maximally} exploit parallelism? What hope is there for developers using languages and systems with little or no concurrency support? How do we help developers ensure that parallelization improves performance?


Session 4 (3:30 - 5:00) - Quality

Concurrent programming has a reputation for being subtle and error-prone. But what kinds of mistakes do programmers really make? What kinds of tools can help developers discover and fix mistakes? What kinds of tools can help developers not make these mistakes in the first place? How can programmers cope with increasingly complex configuration requirements?


Program Committee

  • Bob Blainey (IBM)
  • Joshua Bloch (Google)
  • Ras Bodik (UC Berkeley/Par Lab)
  • Amol Ghoting (IBM)
  • Kevlin Henney (Curbralan Ltd)
  • David Holmes (Oracle)
  • Jim Larus (Microsoft)
  • Doug Lea (SUNY Oswego) -- Co-chair
  • Martin Odersky (EPFL)
  • Bill Pugh (U Maryland)
  • Vijay Saraswat (IBM) -- Co-chair
  • Adam Welc


  • Submission deadline: September 13, 2010
    Note that the Splash early registration deadline is September 16
  • Acceptance notification: September 20, 2010
  • Final copy deadline: October 4, 2010
  • Workshop: October 18, 2010

Doug Lea
Last modified: Sat Oct 16 06:51:29 EDT 2010