+++ /dev/null
-\documentstyle[11pt,slpj,abstracts]{article}
-\begin{document}
-
-% ======================================================
-
-\title{Abstracts of GRIP/GRASP-related papers and reports, 1992
-}
-
-\author{The GRASP team \\ Department of Computing Science \\
-University of Glasgow G12 8QQ
-}
-
-\maketitle
-
-\begin{abstract}
-We present a list of papers and reports related to the GRIP
-and GRASP projects,
-covering {\em the design, compilation technology,
-and parallel implementations of functional programming languages, especially
-\Haskell{}}.
-
-Most of them can be obtained by FTP. Connect to {\tt ftp.dcs.glasgow.ac.uk},
-and look in {\tt pub/glasgow-fp/papers}, {\tt pub/glasgow-fp/drafts}, {\tt pub/glasgow-fp/tech\_reports},
-or {\tt pub/glasgow-fp/grasp-and-aqua-docs}.
-
-They can also be obtained by writing to
-Alexa Stewart, Department of Computing Science,
-University of Glasgow G12 8QQ, UK. Her electronic mail address is
-alexa@dcs.glasgow.ac.uk.
-\end{abstract}
-
-\section{Book}
-
-\reference{Simon Peyton Jones and David Lester}
-{Implementing functional languages}
-{Prentice Hall, 1992}
-{
-This book gives a practical approach to understanding implementations
-of non-strict functional languages using lazy graph reduction.
-
-An unusual feature of the book is that the text of each chapter is
-itself a directly-executable Miranda(TM) program, constituting a
-minimal but complete compiler and interpreter for a particular
-abstract machine. The complete source code for the book, and a
-Tutor's Guide containing solutions to the exercises, is available in
-machine-readable form by network file transfer (FTP).
-
-Written to allow the reader to modify, extend and experiment with the
-implementations provided in the text, this book will help to make a
-course on functional-langauge implementation "come alive".
-
-{\bf Contents}. The Core Language. Template instantiation. The G-machine.
-The Three Instruction Machine. A parallel G-machine. Lambda lifting
-and full laziness. Appendices. Bibliography. Index.
-}
-
-
-\section{Published papers}
-
-\reference{Simon L Peyton Jones}
-{Implementing lazy functional languages on stock hardware:
-the Spineless Tagless G-machine}
-{Journal of Functional Programming 2(2) (Apr 1992)}
-{The Spineless Tagless G-machine is an abstract machine designed
-to support non-strict higher-order
-functional languages. This presentation of the machine
-falls into three parts. Firstly, we give a general discussion of
-the design issues involved in implementing non-strict functional
-languages.
-
-Next, we present the {\em STG language},
-an austere but recognisably-functional language, which as well as
-a {\em denotational} meaning has a well-defined {\em operational} semantics.
-The STG language is the ``abstract machine code'' for the Spineless
-Tagless G-machine.
-
-Lastly, we discuss the mapping of the STG language onto stock hardware.
-The success of an abstract machine model depends largely on how efficient
-this mapping can be made, though this topic is often relegated to a short
-section. Instead, we give a detailed discussion of the design issues and
-the choices we have made. Our principal target is the C language, treating
-the C compiler as a portable assembler.
-
-This paper used to be called ``The Spineless Tagless G-machine: a second
-attempt'', but has been retitled and substantially expanded with new
-material which tries to set the machine in the context of compiler
-technology for other languages. The paper is very long (65 pages) and
-has an index.
-}
-
-\reference{Philip Wadler}
-{The essence of functional programming}
-{Invited talk, 19'th Annual Symposium on Principles of
-Programming Languages, Santa Fe, New Mexico, Jan 1992}
-{
-This paper explores the use monads to structure functional programs.
-No prior knowledge of monads or category theory is required.
-
-Monads increase the ease with which programs may be modified. They can
-mimic the effect of impure features such as exceptions, state, and
-continuations; and also provide effects not easily achieved with such
-features. The types of a program reflect which effects occur.
-
-The first section is an extended example of the use of monads. A
-simple interpreter is modified to support various extra features: error
-messages, state, output, and non-deterministic choice. The second
-section describes the relation between monads and continuation-passing
-style. The third section sketches how monads are used in a compiler
-for Haskell that is written in Haskell.
-}
-
-\reference{A Santos and SL Peyton Jones}
-{On program transformation and the Glasgow Haskell compiler}
-{\GlasgowNinetyTwo{}, pp240-251}
-{We describe a series of program transformations that are implemented
-in the Glasgow Haskell Compiler. They are semantics preserving
-transformations and suitable for automatic application by a compier.
-We describe the transformations, how they interact, and their impact
-on the time/space behaviour of some programs.}
-
-\reference{P Sansom and SL Peyton Jones}
-{Profiling lazy functional languages}
-{\GlasgowNinetyTwo{}, pp227-239}
-{Profiling tools, which measure and display the dynamic space
-and time behaviour of programs, are essential for identifying
-execution bottlenecks. A variety of such tools exist for conventional
-languages, but almost none for non-strict functional languages. There
-is a good reason for this: lazy evaluation means that the program is
-executed in an order which is not immediately apparent from the source
-code, so it is difficult to relate dynamically-gathered statistics
-back to the original source.
-
-We present a new technique which solves this problem. The framework is
-general enough to profile both space and time behaviour. Better still,
-it is cheap to implement, and we describe how to do so in the
-context of the Spineless Tagless G-machine.
-}
-
-\reference{CV Hall, K Hammond, WD Partain, SL Peyton Jones, and PL Wadler}
-{The Glasgow Haskell Compiler: a retrospective}
-{\GlasgowNinetyTwo{}, pp62-71}
-{We've spent much of our time over the last
-two years implementing a new compiler for the functional language Haskell
-In this effort, we've been joined by Andy Gill, who has implemented a
-strictness analyser, Andre Santos, who has contributed a `simplifier', and
-Patrick Sansom, who wrote garbage collectors for our runtime system.
-
-This paper describes some of the things we have learned, what we might
-do differently, and where we go from here.
-}
-
-\reference{D King and PL Wadler}
-{Combining monads}
-{\GlasgowNinetyTwo{}, pp134-143}
-{Monads provide a way of structuring functional programs.
-Most real applications require a combination of primitive monads.
-Here we describe how some monads may be combined with others to
-yield a {\em combined monad}.}
-
-\reference{J Launchbury, A Gill, RJM Hughes, S Marlow, SL Peyton Jones, and PL Wadler}
-{Avoiding unnecessary updates}
-{\GlasgowNinetyTwo{}, pp144-153}
-{Graph reduction underlies most implementations of lazy functional
-languages, allowing separate computations to share results when
-sub-terms are evaluated. Once a term is evaluated, the node of the
-graph representing the computation is {\em updated} with the value of
-the term. However, in many cases, no other computation requires this
-value, so the update is unnecessary. In this paper we take some steps
-towards an analysis for determining when these updates may be omitted.
-}
-
-\reference{S Marlow and PL Wadler}
-{Deforestation for higher-order functions}
-{\GlasgowNinetyTwo{}, pp154-165}
-{Deforestation is an automatic transformation scheme for functional
-programs which attempts to remove unnecessary intermediate data
-structures. The algorithm presented here is a variant of the original,
-adapted for a higher order language. A detailed description of how
-this may be implemented in an optimising compiler is also given.
-}
-
-\reference{WD Partain}
-{The nofib benchmark suite of Haskell programs}
-{\GlasgowNinetyTwo{}, pp195-202}
-{This position paper describes the need for, make-up of, and
-``rules of the game'' for a benchmark suite of Haskell programs. (It
-does not include results from running the suite.) Those of us working
-on the Glasgow Haskell compiler hope this suite will encourage sound,
-quantitative assessment of lazy functional programming systems. This
-version of this paper reflects the state of play at the initial
-pre-release of the suite.
-}
-
-\reference{PL Wadler}
-{Monads for functional programming}
-{Proceedings of the Marktoberdorf Summer School on Programming Calculi,
-ed M Broy, July-August 1992, Springer Verlag}
-{The use of monads to structure functional programs is
-described. Monads provide a convenient framework for simulating
-effects found in other languages, such as global state, exception
-handling, output, or non-determinism. Three case studies are looked at
-in detail: how monads ease the modification of a simple evaluator;
-how monads act as the basis of a datatype of arrays subject to in-place
-update; and how monads can be used to build parsers.
-}
-
-\reference{K Hammond, P Trinder, P Sansom and D McNally}
-{Improving persistent data manipulation for functional languages}
-{\GlasgowNinetyTwo{}, pp72-85}
-{Although there is a great deal of academic interest in
-functional languages, there are very few large-scale functional
-applications. The poor interface to the file system seems to be a
-major factor preventing functional languages being used for
-large-scale programming tasks. The interfaces provided by some
-widely-used languages are described and some problems encountered with
-using these interfaces to access persistent data are discussed. Three
-means of improving the persistent data manipulation facilities of
-functional languages are considered: an improved interface to the file
-system, including a good binary file implementation; an interface to a
-database; and the provision of orthogonal persistence. Concrete
-examples are given using the functional programming language, Haskell.
-}
-
-\reference{Kevin Hammond and Simon Peyton Jones}
-{Profiling scheduling strategies on the GRIP parallel reducer}
-{Proc 1992 Workshop on Parallel Implementations of Functional Languages, Aachen,
-ed Kuchen, Sept 1992}
-{It is widely claimed that functional languages are particularly
-suitable for programming parallel computers. A claimed advantage is
-that the programmer is not burdened with details of task creation,
-placement, scheduling, and synchronisation, these decisions being
-taken by the system instead.
-
-Leaving aside the question of whether a pure functional language is
-expressive enough to encompass all the parallel algorithms we might
-wish to program, there remains the question of how effectively the
-compiler and run-time system map the program onto a real parallel
-system, a task usually carried out mostly by the programmer. This is
-the question we address in our paper.
-
-We first introduce the system architecture of GRIP, a shared-memory
-parallel machine supporting an implementation of the functional
-language Haskell. GRIP executes functional programs in parallel using
-compiled supercombinator graph reduction, a form of
-declarative rule system.
-
-We then to describe several strategies for run-time resource
-control which we have tried, presenting comprehensive measurements of
-their effectiveness. We are particularly concerned with strategies
-controlling task creation, in order to improve task granularity and
-minimise communication overheads. This is, so far as we know, one of
-the first attempts to make a systematic study of task-control
-strategies in a high-performance parallel functional-language system.
-GRIP's high absolute performance render these results credible for
-real applications.
-}
-
-\section{Technical reports}
-
-\reference{CV Hall, K Hammond, SL Peyton Jones, PL Wadler}
-{Type classes in Haskell}
-{Department of Computing Science, University of Glasgow}
-{This paper defines a set of type inference rules for resolving
-overloading introduced by type classes. Programs including type
-classes are transformed into ones which may be typed by the
-Hindley-Milner inference rules. In contrast to an other work on type
-classes, the rules presented here relate directly to user programs. An
-innovative aspect of this work is the use of second-order lambda
-calculus to record type information in the program.
-}
-
-\shortreference{CV Hall}
-{A transformed life: introducing optimised lists automatically}
-{submitted to FPCA 93}
-{}
-
-\shortreference{K Hammond}
-{The Spineless Tagless G-machine --- NOT!}
-{submitted to FPCA 93}
-
-\shortreference{CV Hall}
-{An optimists view of Life}
-{submitted to Journal of Functional Programming, 1993}
-{}
-% ~cvh/Public/Papers/An_Optimists_View.dvi
-
-\end{document}
-
-
-
-
-
projects / ghc-hetmet.git / blobdiff