. Execution profiling plays a crucial part in the performanceimproving process for parallel functional programs. This paper presents the design, implementation, and use of a new execution time profiler (GranSim-SP) for Glasgow Parallel Haskell (GpH). Parallelism is introduced in GpH by using evaluation strategies, which provide a clean way of co-ordinating parallel threads without destroying a program's original structure. The new profiler attributes the cost of evaluating parallel threads to the strategies that created them. A unique feature of the strategic profiler is that the call-graph of evaluation strategies is maintained, allowing the programmer to discover the sequence of (perhaps nested) strategies that were used to create any given thread. The strategic profiler is demonstrated on several examples, and compared with other profilers. 1 Introduction Profiling tools that measure and display the execution behaviour of a program are well established as one of the best ways of tr...

EBG is a lazy functional programming language that compiles to the Java Virtual Machine Language. The aims of EBG are to provide the benefits of both FP and Java. This paper describes the design and implementation of agents in EBG that provides an interface to the underlying multi-processing facilities of Java. 1 Introduction EBG [Cla99a] is a higher-order lazy functional programming language that compiles to the Java Virtual Machine [Ven98]. EBG aims to provide all of the advantages of FP including pattern matching, first class functions and automatic type checking [Fie89], in addition to the advantages of Java [Arn98] including portability, multi-processing, networking and graphical user interfaces. This paper describes the design and implementation of agents in EBG. Agents provide an EBG-level interface to the multi-processing facilities of Java and are a step on the path to a longer term goal of providing programming facilities for functional multi-agent systems [Jen98]. Age...

Abstract. In this paper, we will define a custom term-graph reduction system for a simplified lazy functional language. Our custom system is geared towards flexibility, which is accomplished by leaving the choice of redex free and by making use of single-step reduction. It is therefore more suited for formal reasoning than the well-established standard reduction systems, which usually fix a single redex and realize multi-step reduction only. We will show that our custom system is correct with respect to the standard systems, by proving that it is confluent and allows standard lazy functional evaluation as a possible reduction path. Our reduction system is used in the foundation of Sparkle. Sparkle is the dedicated proof assistant for Clean, a lazy functional programming language based on term-graph rewriting. An important reasoning step in Sparkle is the replacement of an expression with one of its reducts. The flexibility of our underlying reduction mechanism ensures that as many reduction options as possible are available for this reasoning step, which improves the ease of reasoning. Because our reduction system is based on a simplified lazy functional language, our results can be applied to any other functional language based on term-graph rewriting as well. 1

Many predominantly lazy languages now incorporate strictness enforcing primitives, for example a strict let or sequential composition seq. Reasons for doing this include gains in time or space efficiencies, or control of parallel evaluation. This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq whose operational semantics is a variant of one considered by van Eckelen and de Mol, which itself was derived from Launchbury’s natural semantics for lazy evaluation. The main research contributions are as follows: We establish some of the first ever equivalences between programs with selective strictness. We do this by manipulating operational semantics derivations, in

Abstract — This paper suggests a novel computational paradigm for solving numerically intensive problems on a distributed infrastructure. We detail the basic functionality of this new paradigm, its ability to recover from host loss without requiring a complete restart of the code, and how it could allow for many heterogeneous participants to solve a single, large-scale computational problem. We provide results from a small demonstration run as well as provide avenues for future research.

This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq. We establish some of the first ever equivalences between lazy programs with selective strictness by manipulating operational semantics derivations. Our operational semantics is similar to that used by van Eekelen and De Mol, though we introduce a ‘garbage-collecting’ rule for (let) which turns out to cause expressiveness restrictions. For example, arguably reasonable lazy programs such as let y = λz.z in λx.y do not reduce in our operational semantics. We prove some properties of seq, including associativity, idempotence, and left-commutativity. The proofs use our three notions of program equivalence defined