Organizing functional code for parallel execution or, foldl and foldr considered slightly harmful

Authors:
Guy L. Steele, Jr.
Affiliations:
Sun Microsystems Laboratories, Burlington, MA, USA
Venue:
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Year:
2009

Citing 0
Cited 6

Generic multiset programming for language-integrated querying

Proceedings of the 6th ACM SIGPLAN workshop on Generic programming
Dynamic parallelization of recursive code: part 1: managing control flow interactions with the continuator

Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Gradual refinement: blending pattern matching with data abstraction

MPC'10 Proceedings of the 10th international conference on Mathematics of program construction
Generic multiset programming with discrimination-based joins and symbolic Cartesian products

Higher-Order and Symbolic Computation
Higher-Order reactive programming with incremental lists

ECOOP'13 Proceedings of the 27th European conference on Object-Oriented Programming
Refactoring pattern matching

Science of Computer Programming

Quantified Score

Hi-index	0.00

Visualization

Abstract

Alan Perlis, inverting OscarWilde's famous quip about cynics, once suggested, decades ago, that a Lisp programmer is one who knows the value of everything and the cost of nothing. Now that the conference on Lisp and Functional Programming has become ICFP, some may think that OCaml and Haskell programmers have inherited this (now undeserved) epigram. I do believe that as multicore processors are becoming prominent, and soon ubiquitous, it behooves all programmers to rethink their programming style, strategies, and tactics, so that their code may have excellent performance. For the last six years I have been part of a team working on a programming language, Fortress, that has borrowed ideas not only from Fortran, not only from Java, not only from Algol and Alphard and CLU, not only from MADCAP and MODCAP and MIRFAC and the Klerer-May system-but also from Haskell, and I would like to repay the favor. In this talk I will discuss three ideas (none original with me) that I have found to be especially powerful in organizing Fortress programs so that they may be executed equally effectively either sequentially or in parallel: user-defined associative operators (and, more generally, user-defined monoids); conjugate transforms of data; and monoid-caching trees (as described, for example, by Hinze and Paterson). I will exhibit pleasant little code examples (some original with me) that make use of these ideas.