Adrienne G. Bloss

The aggregate update problem in functional programming systems

We discuss the problem of efficiently implementing aggregates (contiguous data structures) such as arrays in functional programming systems. Simple changes to an aggregate conceptually involve making a new copy of the aggregate differing only in the changed component, but such copying can be expensive. We present both static and dynamic techniques for avoiding this copying, and argue that they allow one to program functionally using aggregates, without loss of efficiency over conventional programs.1

Update analysis and the efficient implementation of functional aggregates

Syntax c E Con constants 2 E Bv bound variables P E Pf primitive functions f E Fv function variables e E Exp expressions, where e = c 1 I 1 p(el, . . . . e,) 1 f(el, . . . . e,) pr E Prog programs, where pr = {fi(zl, . . . . 2,) = ei}

Code optimizations for lazy evaluation

Implementations of lazy evaluation for nonstrict functional languages usually involve the notion of a delayed representation of the value of an expression, which we call athunk. We present several techniques for implementing thunks and formalize a class of optimizations that reduce both the space and time overhead of these techniques. The optimizations depend on a compile-time inferencing strategy calledpath analysis, a generalization of strictness analysis that uncovers order-of-evaluation information. Although the techniques in this paper are focused on the compilation of a nonstrict functional language for a conventional architecture, they are directly applicable to most of the virtual machines commonly used for implementing such languages. The same techniques also apply to other forms of delayed evaluation such asfutures andpromises.

Path analysis and the optimization of nonstrict functional languages

The functional programming style is increasingly popular in the research world, but functional languages still execute slowly relative to imperative languages. This is largely because the power and flexibility of functional languages restrict the amount of information readily available to the compiler, hindering its ability to generate good code. This article demonstrates that information about order of evaluation of expressions can be statically inferred for nonstrict functional programs and that optimizations based on this information can provide substantial speedups at runtime. We present an exact, nonstandard semantics called path semantics that models order of evaluation in a nonstrict, sequential functional language, and its computable abstraction, path analysis. We show how the information inferred by path analysis can be used to implement destructive aggregate updating, in which updates on functional aggregates that are provably not live are done destructively. We also demonstrate a new approach to strictness analysis and show that strictness analysis is subsumed by path analysis. Benchmarks are presented.

An optimising compiler for a modern functional language

One of the factors hindering the use of functional languages has been their relatively poor performance in comparison to more traditional languages such as C and Pascal. During the last decade tremendous progress has been made in building implementations of functional languages but the approaches adopted have employed specialist hardware andlor compiler optimisations that have been developed specifically for functional languages. Building specialist hardware may be the best long-term solution but in the short run it is possible to increase the use and acceptance of functional languages by exploiting the performance of commercially available machines. The goal of the project described in this paper has been to design an optimising compiler that produces fast code for functional languages on conventional sequential and parallel machines.

How departments are responding to the mathematics recommendations in CC2001

The Task Force defined a new knowledge area, Discrete Structures, as part of the core body of knowledge that every computer science major must learn, identified a 43-hour block of discrete mathematics material and recommended that this material be taught early in a student’s four-year program so that these concepts can be applied, where appropriate, in later computer science courses. The Task Force presented three models for covering the essential knowledge units in Discrete Structures: a one-semester course, a full-year sequence or an integration of the mathematics topics within an introductory computer science sequence. The Task Force further recommended that additional mathematics in other areas (such as calculus or linear algebra) should also be included in a computer science program, although guidelines for the specific areas or the number of hours that additional mathematics might encompass were not included.

Tools for functional simulation

Functional languages are useful for some types of simulation programming because they offer a clean, high-level programming style with powerful features such as higher-order functions and lazy evaluation. However, since functional languages are not specialized for simulation, they lack the powerful tools offered in simulation languages. In this paper we propose a set of tools to support queueing simulation in the functional language Haskell. The tools are applied to three examples.