terug naar FP-dag-2009 pagina
|10.30-11.00||jur hage||UU||neon, a library for language usage analysis||abstract|
|Tupil||real world wide web haskell
|the harsh reality of commercial functional programming|
|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.40-15.10||marcel van amstel||TUE||kwaliteit van modeltransformaties|
|15.10-15.40||luc engelen||TUE||integratie van grafische en tekstuele modelleertalen|
|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)|
|liefhebbers||voeding en gezelligheid|
Neon, a library for mining Helium
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?
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
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
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?"