Abstract. We present the initial design, implementation and preliminary evaluation of a new distributed memory parallel Haskell, HdpH. The language is a shallowly embedded parallel extension of Haskell that supports high-level semiexplicit parallelism, is scalable, and has the potential for fault tolerance. The HdpH implementation is designed for maintainability without compromising performance too severely. To provide maintainability the implementation is modular and layered and, crucially, coded in vanilla Concurrent Haskell. Initial performance results are promising for three simple data parallel or divide-and-conquer programs, e.g. an absolute speedup of 135 on 168 cores of a Beowulf cluster. 1

Limel is a new systems programming language for constructing efficient, scalable data processing pipelines. Code is written in the style of ML, and the compiler statically specialises the output for execution on either multi-core systems (with call-by-reference semantics) or distributed clusters (with call-by-value semantics), or a combination of both. No modification to the source code is required to swap between calling conventions. Linear typing eliminates the need for a garbage collector, and whole-program monomorphisation means that memory values are not tagged, making the foreign function interface trivial. The big challenge with integrating linear types in day-to-day programming languages is one of usability and expressivity. In this work-in-progress paper, we describe the Limel type system and semantics, and discuss the lessons learnt so far from applying it to various problems such as functional data structures and protocol parsing. 1

Abstract. In this paper we present a seamless approach to writing and compiling distributed code. By “seamless ” we mean that the syntax and semantics of the distributed program remain the same as if it was executed on one node only, except for label annotations indicating on what node sub-terms of the program are to be executed. There are no restrictions on how node labels are to be assigned to sub-terms. We show how the paradigmatic (higher-order functional recursive) programming language PCF, extended with node annotations, can be used for this purpose. The compilation technique is directly inspired by game semantics and the Geometry of Interaction. 1

the date of receipt and acceptance should be inserted later Abstract Multicore and NUMA architectures are becoming the dominant processor technology and functional languages are theoretically well suited to exploit them. In practice, however, implementing effective high level parallel functional languages is extremely challenging. This paper is a systematic programming and performance comparison of four parallel Haskell implementations on a common multicore architecture. It provides a detailed analysis of the performance, and contrasts the programming effort that each language requires with the parallel performance delivered. The study uses 15 ’typical ’ programs to compare a ‘no pain’, i.e. entirely implicit, parallel implementation with three ‘low pain’, i.e. semi-explicit, language implementations. We report detailed studies comparing the parallel performance delivered. The comparative performance metric is speedup which normalises against sequential performance. We ground the speedup comparisons by reporting both sequential and parallel runtimes and efficiencies for three of the languages. To measure the programming effort