terug naar FP-dag-2009 pagina

tentatief programma

 abstracts:

Neon, a library for mining Helium programs.
Jur Hage

Over the years we have collected a large collection of Haskell programs compiled by students with the Helium compiler. In this talk I give examples of the kind of (graphical) results one can obtain, how they can be programmed with Neon in Haskell, and discuss the underlying concepts of Neon.

Haskell, do you read me?
Doaitse Swierstra

The  Haskell definition and implementation of |read| is far from perfect. In the first place |read| is not able to handle the associativities defined for infix operators. Furthermore, it puts  constraints on the way show is defined, and especially forces it to generate far more parentheses than  expected. Lastly, it may give rise to exponential parsing times.
All this is due to the compositionality requirement for read functions, which imposes a top-down parsing strategy.

We propose a different approach, based on typed abstract syntax, in which grammars describing the data types are composed dynamically. Using the transformation libraries described in a  companion paper these syntax descriptions are combined and transformed into parsers at 
runtime, from which the required |read| function are  constructed. In this way we obtain linear parsing times, achieve consistency with the defined associativities, and may use a version of show which generates far fewer parentheses, thus improving readability of printed values.
 

The Hoare state monad
Wouter Swierstra

Monads help structure functional programs. Yet proofs about monadic programs often start by expanding the definition of return and bind. This seems rather wasteful. If we exploit this structure when writing programs, why should we discard it when we writing proofs? I will show how to verify functional programs inhabiting the state monad, with the express aim of taking advantage of the monadic structure of our programs to guide the verification process.
The described transformation algorithms can  be incorporated in a  Haskell compiler, thus moving most of the work involved to compile time.

Specifying Strategies for Exercises
Bastiaan Heeren and Johan Jeuring

The feedback given by e-learning tools that support incrementally  solving problems in mathematics, logic, physics, etc. is limited, or laborious to  specify. In thistalk we introduce a language for specifying strategies for solving  exercises. This language makes it easier to automatically calculate feedback when  users make erroneous steps in a calculation. Although we need the power of a full programming language to specify strategies, we carefully distinguish between context-free and  non-context-free sublanguages of our strategy language. This separation is the key to  automatically calculating all kinds of desirable feedback. The strategy language is  an embedded domain specific language in Haskell.

Real world wide web Haskell
Chris Eidhof and Eelco Lempsink 

In this presentation we will discuss how we have built our first  commercial web application using Haskell. There are a number of  technical and non-technical opportunities and problems we've had. The  techniques helped us create managable code and got us at a high level  of abstraction, but is the world really ready for commercial Haskell  software?"