Parallel computing has always been the ideal field for math wizards and
hackers. Consistency models, locking protocols, non-blocking
communication, lock-free algorithms, and open-nesting are examples of
the complex topics that the experts love to debate. Will mere mortals
ever be able to master such mechanisms in order to process petabytes
of data using thousands of cores?  Unlikely...

This talk will argue that for massive parallelism to become
ubiquitous, we need to adopt higher-level forms of programming. The
abstractions exposed to the programmers should be closer to the
mathematical or physical entities they want to process (sets,
collections, relations, probability distributions,
arrays). Computations should be expressed in a declarative manner that
focuses on the algorithmic properties of the computation rather than
its low-level implementation and management. Notice that nothing about
these high-level programming models says that they have to be
parallel. Nevertheless, I will argue that such models often reveal the
concurrency in the computation in the most flexible, portable, and
scalable manner.

For high-level programming to be effective for ubiquitous parallelism,
we need an extensive infrastructure that can extract, map, and manage
the concurrency it captures. This talk will hopefully initiate a
discussion on some of the many open issues:
\begin{itemize}
\item What are the useful high-level abstractions?
\item How do we synthesize multiple abstractions into one program? 
\item Are domain-specific languages, libraries, or coding patterns the
  way to write high-level programs? 
\item What are the necessary low-level primitives to express the
  concurrency and locality characteristics in the high-level program
  (iterators, messages, futures, transactions, ...)?
\item How much of the mapping & managing problem can we solve statically
   vs. dynamically? 
\item How do we manage scalability and portability? 
\item How do we manage locality? Is scheduling memory more important that
   scheduling cores? 
\item How does the high-level programmer tune such a program? 
\item How do we express and enforce QoS requirements in this environment
   (real-time, power, ...)? 
\item What performance overhead does the high-level approach incur? Do we
  need to spend half of the resources to continuously monitor, manage, and compile
  program? Is that the best we can do? 
\item Does knowledge of the high-level requirements of the computation
  helps us bypass or optimize some of the age-old issues with parallel
  computing? 
\end{itemize}