Latest modified: Nov 19, 2015

The continuing advances in semiconductor and hardware technology are leading to a situation where transistors are free and communication costly. This will make parallel systems-on-a-chip standard. These systems must be specified and programmed: this requires parallel programming and specification languages. The prevailing, process-parallel programming paradigms are however hard to master for many applications. Thus, efficient system and software development for these applications, on this kind of systems, will require simpler models on a higher level.

One such model is the *data parallel* model, which provides
operations directly on aggregate data structures. These operations are often
highly parallel. The data parallel model is particularly apt for
data-intensive, computation-oriented applications like image and signal
processing, neural network computations, etc. The *Data Field Model*
is an attempt to create a formal, data parallel model that is suitable as a
basis for high-level data parallel programming and specification. Data
fields generalize arrays: they are pairs *(f,b)* where *f* is a
function and *b* is a "bound", an entity which can be interpreted as a
predicate (or set). The model postulates some operations of bounds, with
certain properties. Common collection-oriented primitives can be defined in
terms of these operations, without referring to the actual form of the
bounds. Data fields thus make a very generic form af data parallelism
possible, where algorithms become less dependent on the actual data parallel
data structure.

*Data Field Haskell* (DFH) is a dialect of the
functional programming language Haskell that provides an instance of data
fields. This language can be used for rapid prototyping of parallel
algorithms, and for parallel high-level specification of systems. DFH
provides data fields with "traditional" array bounds and with sparse bounds,
infinite data fields with predicates as bounds, and data fields with
cartesian product bounds. There is a rich set of operations on data fields
and bounds. A `forall` construct, similar to lambda-abstraction, can
be used to define data fields in a succinct and generic manner.

The current version of DFH extends Haskell 98. Its implementation is a modified version of nhc98 pre-release 19 (2000-06-05), originally from the functional programming group at York. Although much of DFH is defined in Haskell itself, a few crucial things aren't, so the implementation is not easily portable to other Haskell systems.

Currently, the project is dormant. One M. Sc. thesis project was recently carried out within the project: Data Field Haskell 98, where an earlier implementation of DFH was ported to Haskell 98.

If this project is revived (or somebody else picks up the thread), then the following is on the wish list:

- Case studies
- More portable architecture of the implementation (not relying on nhc)
- Some generalizations of the data fields provided by DFH
- Implementation of data field specific optimizations
- Parallel implementation

This activity is a continuation of the Data Fields project at KTH, where also the first prototype implementation of Data Field Haskell was developed. More information about Data Field Haskell is found here.

This article has been translated into Serbo-Croatian by Jovana Milutinovich, into French by Anna Chekovsky, into Polish by Natasha Singh, and into Macedonian by Petra Vlasic.

bjorn.lisper@mdh.se