Helium, for learning Haskell

@inproceedings{Heeren2003HeliumFL,
  title={Helium, for learning Haskell},
  author={Bastiaan Heeren and Daan Leijen and Arjan van IJzendoorn},
  booktitle={Haskell '03},
  year={2003}
}
Helium is a user-friendly compiler designed especially for learning the functional programming language Haskell. The quality of the error messages has been the main concern both in the choice of the language features and in the implementation of the compiler. Helium implements almost full Haskell, where the most notable difference is the absence of type classes. Our goal is to let students learn functional programming more quickly and with more fun. The compiler has been successfully employed… 
View on ACM
microsoft.com
97 Citations
Highly Influential Citations
17
Background Citations
31
Methods Citations
27
Results Citations
3

Figures from this paper

97 Citations

Mining for Helium

TLDR
A library in Haskell, called Neon, is developed for computing characteristics of this collection of Haskell programs written by students in a first-year functional programming course using the Helium compiler and presenting the results visually.

Mining Helium programs with Neon

TLDR
A sizable library in Haskell, called Neon, is developed for computing characteristics of this collection of Haskell programs written by students in a first-year functional programming course using the Helium compiler.

Investigating Compilation Errors of Students Learning Haskell

TLDR
This study investigates compilation errors of novice Haskell students and makes suggestions on how their learning efficiency can be improved by uncovering the root problems with the student solutions by analysing samples of their submissions.

Heat — An Interactive Development Environment for Learning & Teaching Haskell

TLDR
Heat proves that a small portable interactive development environment can be implemented on top of but independent of a particular Haskell interpreter, and is used in teaching functional programming at the University of Kent.

Study on difficulties and misconceptions with modern type systems

TLDR
Student difficulties are identified with means of multiple choice questions embedded into the on-line materials of an introductory functional programming course and the most prevalent misconceptions were confusing with parametric polymorphism with subtyping, the assigning too much meaning to variables names, and confounding general language patterns with special cases.

The Helium Logging Facility

TLDR
Parts of how the logging between the compiler implemented in Haskell and a specially built Java server proceeds are described, described mainly from a technical point of view: what is sent, how is it sent, and some of the safety measures the authors have taken to avoid misuse and abuse.

Analyzing Helium Programs Obtained Through Logging - The process of mining novice Haskell programs -

TLDR
This document presents the work of collecting and analyzing the data sets, and is able to provide empirical evidence for claims that are hardly challenged in the research field of computer science and functional programming.

A Block Design for Introductory Functional Programming in Haskell

  • Matthew Poole
  • Computer Science
    2019 IEEE Blocks and Beyond Workshop (B&B)
  • 2019
TLDR
The design of blocks for editing code in the functional language Haskell is described to help students learn Haskell’s sophisticated type system which is often regarded as challenging for novice functional programmers.

The architecture of the Utrecht Haskell compiler

TLDR
The architecture of the Utrecht Haskell Compiler is described, which is a new Haskell compiler, that supports most (but not all) Haskell 98 features, plus some experimental extensions, plusSome experimental extensions.

Type Class Directives

TLDR
Four type class directives, and specialized type rules are proposed to lend high-level support to compilers to improve the type error messages in the presence of Haskell 98 type classes.
...

References

SHOWING 1-10 OF 21 REFERENCES

Parametric Type Inferencing for Helium

TLDR
This paper documents the implementation of the Helium type inferencer, a compiler for a large subset of Haskell under development at Universiteit Utrecht, which can be parameterized in a number of ways.

Scripting the type inference process

TLDR
It is shown how four techniques which influence the behaviour of constraint-based type inference processes can help to generate error messages which are conceptually closer to the domain for which the library was developed.

Haskell - the craft of functional programming

  • S. Thompson
  • Computer Science
    International computer science series
  • 1996
TLDR
The second edition of Haskell: The Craft of Functional Programming is essential reading for beginners to functional programming and newcomers to the Haskell programming language, with an emphasis on software engineering principles.

Freja, Hat and Hood - A Comparative Evaluation of Three Systems for Tracing and Debugging Lazy Functional Programs

TLDR
This paper compares three systems for tracing and debugging Haskell programs: Freja, Hat and Hood and identifies the strengths and weaknesses of each system and form ideas on how the systems can be improved further.

DrScheme: a programming environment for Scheme

TLDR
Beyond the ordinary programming environment tools, DrScheme provides an algebraic stepper, a context-sensitive syntax checker, and a static debugger that explains specific inferences in terms of a value-flow graph, selectively overlaid on the program text.

Object-Oriented Style Overloading for Haskell

Type error slicing in implicitly typed higher-order languages

Parsec: direct style monadic parser combinators for the real world

TLDR
The Parsec parser combinator library described in this paper, utilizes a novel implementation technique for space and time e±cient parser combinators that in case of a parse error, report both the position of the error as well as all grammar productions that would have been legal at that point in the input.

Building program optimizers with rewriting strategies

TLDR
An extended language in which the side-conditions and contextual rules that arise in realistic optimizer specifications can themselves be expressed as strategy-driven rewrites, and a low-level core language which has a clear semantics, can be implemented straightforwardly and can itself be optimized.

Principal type-schemes for functional programs

Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of…