Distribution has become a necessity for the majority of computing domains, but developing distributed applications remains a highly delicate and complex task. Several emerging distributed computing and application domains, including cloud computing, service-oriented computing, stream processing, sensor networks, and context-aware computing, pose unprecedented challenges to the programmer. Applications in these domains can deliver tangible benefits to the user once they enter the mainstream of industrial software development. What is hindering the wide adoption and use of these applications is the prevalence of ad-hoc programming practices in their software development process. The goal of this workshop is to explore programming support innovations that can address the incongruence between the advanced programming requirements of emerging distributed applications and the current state of the art of their programming support. To that end, the workshop will provide a venue for free and open discussions among academic researchers and industry practitioners of distributed applications.

This workshop will explore programming challenges of the emerging domains including:

• Service-oriented computing
• Cloud computing
• Stream processing
• Sensor networks
• Context-aware computing
• Cyber-physical systems
• Geo-spatial systems
• Data-intensive computing

Addressing challenges that arise in the development of such emerging distributed applications requires programming support innovations in abstractions, techniques, and tools, for which this workshop aims at providing a receptive and critical audience.

Keynote Speaker 1

Toward Compositional Programming of Distributed Applications Download (PDF)
Dr. John Field (IBM T.J. Watson Research Center)

Abstract:
The distributed systems community has made enormous progress over the past few decades designing specialized systems that scale to handle millions of users and petabytes of data. However, combining individual systems into composite applications that are scalable---not to mention reliable, secure, and easy to maintain---remains an enormous challenge. This is where programming languages should be able to help: good languages are designed to facilitate composing large applications from smaller components, and for reasoning about the behavior of applications modularly. But most languages offer little if any support for distributed programming. Can we design better languages that will help us to build better systems?

In this talk, I will review some of the successful system design concepts that I believe deserve greater prominence in future programming languages and discuss some of the challenges composing these concepts. I will then describe some small steps my colleagues and I have taken on the road to compositional distributed programming. In particular, I will argue that the Actor model of concurrency is a good foundation for distributed applications in which concurrency arises reactively---in response to external or internal events, signals, or messages; or in which concurrency arises dynamically---as a consequence of variations in input structure. Applications that exhibit one or both of these properties include web applications, transaction processing, workflow, stream/event processing, and certain data mining algorithms. I will illustrate some of our ideas using examples from the Thorn programming language, which is being developed jointly by IBM and Purdue University.

The work on Thorn is joint with B. Bloom, B. Burg, J. Dolby, N. Nystrom, J. Östlund, G. Richards, R. Strniša, E. Torlak, J. Vitek, and T. Wrigstad.

Bio:
John Field is a Research Staff Member at IBM's T.J. Watson Research Center and manager of the Advanced Programming Tools Group. He received a Ph.D. from Cornell University in 1991, where he was a member of the team that built the Synthesizer Generator, a multi-lingual IDE that was subsequently developed into a suite of programming productivity tools by Grammatech, Inc. At IBM, his research has centered on the design of tools and programming models for large software systems, with the aim of increasing programmer productivity and software quality. Most recently, his work has focused on tools and programming models for distributed and concurrent applications. Tools and techniques developed by the Advanced Programming Tools Group have been incorporated into a number of IBM application development products, including the VisualAge Cobol suite, the VisualAge Y2K Analysis and Remediation Toolkit (which received an Outstanding Technical Achievement Award from IBM), IBM DB2's Database Migration Toolkit, and IBM Rational's AppScan DE web security tool.

Keynote Speaker 2

Towards Enabling High-Performance for Multi-Language Programs and Systems Download (PDF)
Prof. Chandra Krintz (UCSB)

Abstract:
Large, scalable, distributed software systems are increasingly implemented using collections of components to better manage software complexity through reusability, modularity, and fault isolation. Since each programming language has its own unique combination of performance, speed of development, library support, and developer communities, different software components are often implemented in different languages. For example, Ruby, Python, Java, and JavaScript facilitate fast development of the web presentation layer, Java, PHP, Perl, Python, and Ruby expedite development of efficient server-side logic, and Java, query languages, and C++ are accelerate backend data management. The components of these multi-language, multi-component applications and mashups typically execute within independent runtime systems (language virtual machines (VMs), interpreters, etc.) and communicate and interoperate via remote procedure calls (RPC) and message passing.

Although, multi-language application composition provides many benefits to programmer productivity and fault tolerance, it also poses many challenges to traditional runtime and distributed system support. Such challenges include how to profile and characterize application performance/behavior across language components and across multi-language workloads, how to adaptively place of code and data to make efficient use of distributed resources, and how to exploit co-location of components (those executing on the same physical resource) to improve communication performance between isolated runtime systems. Such support is increasingly important for performance-sensitive applications that execute using systems that simplify the use of distributed systems (e.g. clouds) by making resources and services opaque to developers. In this talk, we will overview this execution model and the challenges it poses. We will also identify and discuss new techniques that target and address these challenges in a effort to facilitate high-performance for the next-generation of distributed multi-language software.

Bio:
Chandra Krintz is an Associate Professor at the University of California, Santa Barbara (UCSB). She joined the UCSB faculty in 2001 after receiving her M.S. and Ph.D. degrees in Computer Science from the University of California, San Diego (UCSD). Chandra's research interests include automatic and adaptive compiler, programming language, virtual runtime, and operating system techniques that improve performance (for high-end systems) and that increase battery life (for mobile, resource-constrained devices). Her recent work focuses on programming language and runtime support for cloud computing. Her group has recently developed and released AppScale -- an open-source platform-as-a-service cloud computing system that implements the Google App Engine (GAE) APIs that facilitates next-generation cloud computing research. Chandra has supervised and mentored over 40 students, has published her work in a wide range of ACM venues including CGO, ECOOP, PACT, PLDI, OOPSLA, ASPLOS, and others, and leads several educational and outreach programs that introduce computer science to young people, particularly those from underrepresented groups. Chandra's efforts have been recognized with a 2006 NSF CAREER award, the 2008 CRA-W Anita Borg Early Career Award (BECA), and the 2008-9 UCSB Academic Senate Distinguished Teaching Award. Chandra is also an ACM and IEEE Senior Member.

8:30-9:00 Introductions

9:00-10:00 Keynote 1: John Field

10:00-10:30 Coffee Break

10:30-12:00 Paper Session 1

1. Adam Welc, Richard L. Hudson, Tatiana Shpeisman and Ali-Reza Adl-Tabatabai
   Generic Workers - Towards Unified Distributed and Parallel JavaScript Programming Model
2. Samah Gad
   Sync and Learn: Data Synchronization Design Pattern for Sensor Based Mobile Learning Systems
3. Emilie Balland and Charles Consel
   Open Platforms: New Challenges for Software Engineering

12:00-1:30 Lunch Break

1:30-2:30 Keynote 2: Chandra Krintz

2:30-3:00 Paper Session 2

Kurt Rohloff and Richard E. Schantz
High-Performance, Massively Scalable Distributed Systems using the MapReduce Software Framework: The SHARD Triple-Store

3:00-3:30 Coffee Break

3:30-4:00 Paper Session 3

Hussain Almohri and Osman Balci
Virtual Execution of Net-Centric Software Design Models

4:00-5:00 Panel

Programming the Cloud: Challenges & Opportunities

Charles Consel (INRIA / University of Bordeaux, France)
John Field (IBM T.J. Watson Research Center)
Wolfgang De Meuter (The Vrije Universiteit, Brussel.)
Chandra Krintz (UCSB)
Kurt Rohloff (BBN Technologies)

Distributed applications present some of the most salient challenges for researchers and practitioners alike. The goal of this workshop is to explore programming support innovations for emerging distributed applications with respect to programming support, including abstractions, techniques, and tools.

Possible topics for contributions include, but are not limited to:

• Programming frameworks
• Domain specific languages
• Code generators
• Middleware systems
• Program transformation systems
• Extensible languages
• Component technologies
• Product-line architectures
• Advanced separation of concerns

All papers must be submitted electronically, in PDF format, through EasyChair. Submissions must not exceed 5 pages, in the ACM SIGPLAN 10 point format. Templates for Word and LaTeX are available at http://www.acm.org/sigs/sigplan/authorInformation.htm.

• Submission deadline: August 9, 2010
  August 30, 2010
• Acceptance notification: September 19, 2010
• Camera-ready deadline: TBD
• Workshop day: October 17, 2010

Program Committee Chairs

• Eli Tilevich (Virginia Tech, USA)
• Patrick Eugster (Purdue University, USA)

Program Committee

• Gustavo Alonso (ETH Zürich, Switzerland)
• Godmar Back (Virginia Tech, USA)
• Shigeru Chiba (Tokyo Institute of Technology, Japan)
• Charles Consel (INRIA / University of Bordeaux, France)
• John Field (IBM Research, USA)
• Buğra Gedik (IBM Research, USA)
• Jon Howell (Microsoft Research, USA)
• Hans-Arno Jacobsen (University of Toronto, Canada)
• Christine Julien (UT Austin, USA)
• Valérie Issarny (INRIA Paris - Rocquencourt, France)
• Chandra Krintz (UCSB, USA)
• Erik Meijer (Microsoft Research, USA)
• Richard Schantz (BBN Technologies, USA)
• Liuba Shrira (Brandeis University, USA)
• Mario Südholt (École des Mines de Nantes, France)

Web Master

• Young-Woo Kwon (Virginia Tech, USA)