terug naar FP-dag-2009 pagina

tijd | wat/wie | affiliatie | waarover | opm |

09.30-10.00 | ontvangst | |||

10.00-10.01 | opening | |||

10.01-10.30 | bastiaan heeren johan jeuring |
OU | recognizing
strategies |
abstract |

10.30-11.00 | jur hage | UU | neon, a library for language usage analysis | abstract |

11.00-11.20 | pauze | |||

11.20-11.50 | chris eidhof eelco lempsink |
Tupil | real world wide web haskell |
abstract |

11.50-12.20 | paul stravers | Vector fabrics |
the harsh reality of commercial functional programming | |

12.20-13.20 | lunch | |||

13.20-13.50 | wouter swierstra | Univ Nott | the hoare state monad | abstract |

13.50-14.20 | bas lijnse | RUN | pimp my workflow system | |

14.20-14.40 | pauze | |||

14.40-15.10 | marcel van amstel | TUE | kwaliteit van modeltransformaties | |

15.10-15.40 | luc engelen | TUE | integratie van grafische en tekstuele modelleertalen | |

15.40-16.00 | pauze | |||

16.00-16.30 | marcos viera | UU | first class attribute grammars | |

16.30-17.00 | doaitse swierstra | UU | haskell, do you read me? | abstract |

17.00-17.01 | sluiting | vastleggen volgende FP-dag (next time) | ||

17.01-18.00 | borrel | |||

liefhebbers | voeding en gezelligheid |

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 deﬁnition 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 veriﬁcation
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?"