The Untyped Array Calculus --- Its Syntax and Semantics

Kai Trojahner, University of Lübeck

In this talk, I describe the untyped array calculus, a smooth embedding of the lambda calculus into the world of multidimensional arrays. The calculus captures the essence of SaC without any syntactic sugar or restrictions imposed to achieve high computing performance. Instead, the untyped array calculus drives the "everything-is-an-array" idea to its utmost consequence. The key idea is the syntactic separation of the representation of expressions from the representation of array elements which are called quarks. This very naturally allows for arrays of functions, arrays of tuples, and even arrays of arrays. The semantics of the calculus is defined in terms of a natural semantics. I would like to use the opportunity to put the initial design up for discussion.

The Typed Array Calculus

Kai Trojahner, University of Lübeck

The untyped array calculus, although powerful, introduces a huge potential for writing programs that will not evaluate to a value. Type systems statically identify many bad programs ("Well typed programs do not go wrong"). In this talk, I discuss a type system for the array calculus that, analogous to expressions and quarks, employs types and quark types. To symbolically capture array ranks and shapes and to statically verify array accesses, the type system uses a light-weight form of dependent types. Since this work is very much in progress, I am looking forward to the feedback from the DevCon participants!

What's the Problem with Multi-Threading?

Clemens Grelck, University of Hertfordshire

The generation of multi-threaded code has not been available for an awfully long time. This talk gives some insights on why multi-threading cannot be resurrected so easily. We outline the intended solution developed so far and sketch out the state of the ongoing implementation.

Side-Effects in With-Loops -- the Unleashing and the Taming of the Non-Determinism Beast

Sven-Bodo Scholz, University of Hertfordshire

Theo has enabled side-effecting operations within With-Loops. While pragmatic in several real-world applications such as pixel-wise printing this extension inherently introduces the potential for non-deterministic results. This talk discusses the approach taken by Theo: the consistency guarantees achieved and their technical realisation. Furthermore, the talk proposes a slight extension of Theo's approach which would allow the programmer to control the non-determinism more tightly.

How Lazy Should Efficient Array Programming Be?

Sven-Bodo Scholz, University of Hertfordshire

Although eager on first glance, SaC's main performance edge stems from the laziness introduced by most of our optimisations. In fact, the shape-invariant programming style relies on these optimisations to be effective. Unfortunately, the laziness that derives from our optimisations in some situations is not powerful enough to allow for nice "wholemeal" specifications of array programs. This talk summarises the state-of-the-art in laziness of sac2c and it outlines the challenges for extending it without sacrificing performance in general.

A Lazy Array Semantics for SAC and some Notes on Implementation

Clemens Grelck, University of Hertfordshire

SAC has a strict semantics. Full stop. That has been almost dogmatic since the early days. In fact, we use quite some laziness for optimisation purposes. The problem is that optimisations are always optional and may or may not work under certain circumstances. As a consequence, many elegant code examples rely on the compiler to work effectively. We propose a mixed lazy/strict semantics and sketch out some implementation paths.

A Multi-Threaded Runtime System for S-Net

Frank Penczek, University of Lübeck

S-Net is a declarative coordination language for describing streaming networks of asynchronous components. In this talk, I will introduce the design of a multi-threaded runtime system for S-Net. Apart from the design, some interesting implementation details will be pointed out. The talk also includes a brief introduction to S-Net

Idea, Use and Implementation of Symbolic Array Attributes in sac2c

Florian Büther, University of Lübeck

Augmenting the arrays in a functional array language with information about their dimension or rank and shape is an essential method to optimise the compilers behaviour in two different ways. They are mainly used for easing memory access and secondly to gather more information at compile time. These both aid in generating faster runtime code.

Record Types -- Typed Records

Stephan Herhut, University of Hertfordshire

Records and Record Types can be used as a flexible means of data and type representation. They allow for a high-level of abstraction and generic programming style, combined with utmost flexibility in representation and static and/or dynamic type knowledge. I will present a type system using record types and showcase the expressive power it offers.

Cutting the Crap: a Proposal for Re-Designing the Primitive Operations

Sven-Bodo Scholz, University of Hertfordshire

The first version of SaC introduced a large set of APLish array primitives. In the context of the redesign of the type system of SaC, a large part of these were eliminated or restricted to some special cases. Alongside with this "migration" from powerful APL primitives to C-like primitives, several pseudo-primitives were added as a convenient vehicle to represent intermediate code representations. As a consequence of all these developments, today, we have a rather inconsistent and less well documented [warning: rather English statement] set of primitive operations with not exactly complete implementations. To counter this situation, I want to propose a revised version of primitives and I want to discuss a few possible implementation paths.

SAC4C: On Binding C and SAC

Stephan Herhut, University of Hertfordshire

Due to the new module system and internal compiler infrastructure, revamping the SAC C-interface is inevitable. I propose a less alien and more integrated approach by modelling C-wrapper as an interface layer on top of SAC modules and thereby decoupling C-wrapper generation from the SAC compiler. Apart from the conceptual ideas, I will further present an outline of their implementation.

Whither SAC or Wither SAC?

Robert Bernecky, University of Toronto

Image Registration Using SAC

Kai Trojahner (joint project with Markus Weigel), University of Lübeck

In collaboration with the University of Lübeck's world-famous SAFIR - Solutions and Algorithms for Image Registration group, Markus and I evaluated in how far SaC is suitable as a tool for real-world numeric computations. I will give a brief presentation of the results of the collaboration.

»Niche Array Languages« and Their Success and Failure in Business Today

Walter Fil, Future Perfect Ltd.

Robert Bernecky

University of Toronto

Canada

Florian Büther

University of Lübeck

Germany

Walter Fil

Future Perfect Ltd.

Switzerland

Torben Gerhards

Christian-Albrechts-Universität zu Kiel

Germany

Clemens Grelck

University of Hertfordshire

United Kingdom

Stephan Herhut

University of Hertfordshire

United Kingdom

Frank Penczek

University of Lübeck

Germany

Robert Piper

University of Hertfordshire

United Kingdom

Sven-Bodo Scholz

University of Hertfordshire

United Kingdom

Alex Shafarenko

University of Hertfordshire

United Kingdom

Kai Trojahner

University of Lübeck

Germany

Carlos Huertas Villegas

University of Baja California

Mexico