You are here: UUCS>FPDag2012 Web>WebHome (06 Aug 2014, AtzeDijkstra)EditAttach

Welcome to the FPDag2012 web

Location, Time

The next Dutch National Functional Programming Day (landelijke FP dag):

date January 6, 2012
location Witte zaal , Ruppert building, the Uithof
time 10-17 :30

Mailing list

There exists a low-traffic mailing list for information about specifically Dutch functional programming subjects. You can subscribe here. The list is moderated, both with respect to subscription as with respect to posting in order to keep traffic low and to avoid spam.


In order to coffee and tea please let me know that you will be coming. I will add your name to the end of the page. Please also let me know whether you want to participate in the dinner (a (+) will show up behind your name).

Since the meeting will take place in the Ruppert (formerly called Trans I) building, where we are close to the Educatorium, we have planned to have a joint lunch there, which you will have to select and pay for yourself (ordering a lunch is expensive, and you might not get what you want). The department is currently quite poor and asking a registration fee is not worth the effort. In the Educatorium there is a possibility to go upstairs where I expect to be able to sit together (it will not be very busy since there are no lectures that week).

How to get there

At the station take bus 11 or 12, and get off at the center of the campus (near the library, stop Heidelberglaan). Enter the doors under the highest building you see, and follow the corridor going North, until you get to the place where the Educatorium and the Ruppert building are joined. Turn right there. The Witte Zaal is then on your left.


10:00 Coffee

10.30 Ask-Elle - a Haskell tutor, Johan Jeuring (UU/OU)

In this talk we will introduce Ask-elle, a Haskell tutor. Ask-Elle supports the incremental development of Haskell programs. It can give hints on how to proceed with solving a programming exercise, and feedback on incomplete student programs. We will show Ask-Elle in action, discuss how you can configure its behaviour, and some of the underlying technology to achieve this behaviour.

11.00 Multi-Purpose Shared Data Sources in a Functional Language, Steffen Michels, Nijmegen

Modern software systems deal with huge amounts of data from different sources. Data is stored at different locations, like in memory, in files, or in databases. Multiple threads, processes and remote machines access the same data concurrently. Many different solutions exist for solving different issues emerging from this. This include methods for abstracting from the actual storage, controlling access and keeping data consistent in case of concurrent accesses.

In this paper multi-purpose shared data sources, abstracting from all details but the type of data provided and received, are introduced. They provide a uniform way for dealing with various kinds of data sources, providing solutions for all of the issues mentioned above. Access control is achieved using the type system. Compositional, safe operations can be defined using atomic transactions. Finally, functional projections can be used to change the way data is accessed and sources can be combined. This makes is possible to abstract from how data is stored and distributed, which leads to highly reusable code.

11.30 Model Based Testing with Logical Properties versus State Machines, Pieter Koopman, Nijmegen

Model-based testing of single functions is usually based on logical properties as specification. In practice it appears to be rather hard to develop a sufficiently strong set of properties to spot all errors. For model-based testing of state based systems one usually employs a state machine as model and a conformance relation between this specification and the software under test. For (abstract) data types we can use both ways of model-based testing. In this paper we compare the specification effort required to make an effective model and the effectiveness of the associated tests for some well-known data types. Our examples show that it can be easier to write state based specifications. Moreover, conformance based testing of data types is more effective and very efficient.

12:00 Lunch

13.00 Holmes for Haskell: Keeping your Haskell courses free of software plagiarists, Jurriaan Hage, Utrecht

As the popularity of Haskell increases, and course developers use it as the subject of a first functional programming course, many would-be Haskellers may try to pass those courses the easy way: by copying from their peers, predecessors, or the Web.

To counter program plagiarism for Haskell, we have implemented a tool called Holmes that aims to detect plagiarism by assigning similarity scores to pairs of modules and submission based on the source code. The tool was developed following an earlier study that aimed to discover a small but strong selection of heuristics that are predictive enough to discover plagiarism, but also insensitive to various obvious ways of covering up plagiarism. It is implemented on top of the Haskell package haskell-src-exts, and works for anything that haskell-src-exts accepts.

We report on our experiences in using the tool for a collection of 2,122 Haskell submissions spread over 18 different assignments. In total we found 66 clear cut cases of plagiarism/fraud and 12 additional cases in which the students should be questioned. Holmes is available to (verifiable) teachers of Haskell on request from the first author.

13.30 Giving Haskell a Promotion, José Pedro Magalhães, Utrecht

Haskell is known for its expressive static type system that helps ensuring that programs behave well at runtime. With the advent of advanced type system features such as generalized algebraic datatypes and type families, type-level programming became commonplace in Haskell. Unfortunately, Haskell's kind system remained very primitive so far, making type-level programming rather untyped. A new GHC extension comes to solve this problem by promoting two type-level features to the kind level: polymorphism and datatypes. In this talk I show how to take advantage of the new features for writing better programs, and provide some insight on the compiler support for this new feature.

14.00 What not to wear to a Hardware Party - A Mechanized Stylist, Christiaan Baaij (Twente)

Polymorphism and higher-order functions are great tools for making functional hardware descriptions more concise and abstract. Trying to fit these concepts in a netlist view of functions, where function arguments become physical ports of a hardware component, seems unfeasible. How many electrical wires would I need to represent something of "a -> b"? Given proper restrictions on the functional description, we can transform it however, making the entire function hierarchy monomorphic and first-order. The presentation will introduce the workings of the rewrite system that performs this transformation, and elaborate on the restrictions placed on the functional hardware descriptions.

14.30 Improving the UHC JavaScript Backend, Jurrien Stutterheim

At the previous NLFP-Day, we saw the UHC JavaScript backend; a compiler backend that allows you to compile Haskell code to JavaScript. Since then, the backend has seen some significant improvements; most notably the addition of support for JavaScript objects and foreign dynamic and wrapper imports. In this talk we briefly look at how the JavaScript backend works, after which we will discuss the latest features in more detail.

15:00 Tea

15:30 Xmonad in Coq: Programming a window manager with a proof assistant, Wouter Swierstra

In this talk, I want to share my experience using Coq and Coq's extraction to Haskell as part of a non-trivial software project. In particular, I want to discuss how I've used Coq's extraction mechanism to verify parts of XMonad, a X window manager written in Haskell. Clearly this should work in theory -- but nobody seems to be using this technology in practice. Why not?

16:00 How to dress up a camel in Python's clothing, Alexey Rodriguez, Vectorfabrics

Functional programming is great! Software developed using it is more reliable, the productivity of programmers is enhanced, code bases are more maintainable, the list goes on and on. Vector Fabrics believes in it and uses Ocaml to develop state-of-the-art tools that extract parallelism out of formerly sequential C code.

However, turning an FP code base into a scriptable software product is not easy. What should the scripting language of choice be? Choose the FP language used for development, for example Ocaml, and casual scripting users will be intimidated by the learning curve. Instead, it is common practice to use languages with a gentle learning curve, for example Python, as the scripting language for the product. This choice enables a larger user base to take advantage of the scripting features. However, for an FP project, this will require solving the problems that arise from interfacing the FP language with the scripting language.

In this talk, we will report on our experience in exposing the functionality of our Ocaml codebase through a Python scripting API. We will explain our design choices, describe the problems we encountered in different areas (marshaling across programming languages, complex interactions with garbage collection, exceptions, turning the Ocaml runtime into a shared library), and recount entertaining war stories.

We think the effort is worth it. Casual scripting users are now able to harness powerful parallelization analyses written in Ocaml, dressed up as innocuous Python function calls.

16:30 Attribute-directed Hints for Controlling Ordered Attribute Grammar Evaluation, Arie Middelkoop, LIP6-REGAL (UU)

An attribute grammar with a statically determined evaluation order is translatable to a monadic evaluation algorithm. Generic translations are possible to monads that provide facilities for debugging and concurrency. In general, such facilities can be exploited more effectively using program-specific hints that have knowledge about the values computed by the program. We show on-going work about how to incorporate such hints in an attribute grammar using monadic rules with a special scheduling policy.

17:30 Joint Dinner at La Fontana

The dinner will be in the pizzeria La Fontana, which is easily reachable by taking bus 11 back to the city. Get off the bus at the Neude, follow the direction of the bus, and just across the Oudegracht canal on the corner you will find the restaurant. If you come by car, it is probably advisable to leave it at the Uithof and take the bus.

Grotere kaart weergeven

We have to choose from:



(+) indicates dinner too

  • Thijs Alkemade (+)
  • Christaan Baaij (+)
  • Dander van de Berg
  • Jan Bessai (+)
  • Nikolaos Bezirgiannis
  • Annette Bieniusa (?)
  • [deleted on request] (+)
  • Roel van Dijk (+)
  • Atze Dijkstra (+)
  • Eelco Dolstra (+)
  • Erik Drijfhout
  • Wanno Drijfhout
  • Joeri van Eekelen (+)
  • Alexander Elyasov (?)
  • Lucilia de Figueiredo
  • Rik van Geldrop (+)
  • Ruben de Gooijer (+)
  • Jeroen Goudsmit
  • Bas de Haas
  • Jurriaan Hage (+)
  • Bastiaan Heeren (+)
  • Jeroen Henrix (+)
  • Jelle Herold (+)
  • Erik Hesselink (+)
  • Yoichi Hirai (+)
  • Pascal Hof (+)
  • Stefan Holdermans (+)
  • Jan Martin Jansen (+)
  • Johan Jeuring (+)
  • Christian John (+)
  • Steven Keuchel (+)
  • Matthijs Kooijman
  • Pieter Koopman
  • Pjotr Kourzanov
  • Mathijs Kwik (+)
  • Twan van Laarhoven (+)
  • Sean Leather (+)
  • Jeroen Leeuwestein (+)
  • Bas Lijnse (+)
  • Tom Lokhorst (+)
  • José Pedro Magalhães (+)
  • Steffen Michels (+)
  • Arie Middelkoop (?)
  • Thomas van Noort (+)
  • Ruud Koot (+)
  • Vincent van Oostrom
  • Markus Palmanto (+)
  • Rinus Plasmeijer (+)
  • Alexey Rodriguez
  • Jan-Willenm Roorda
  • Nick Rudnick (+)
  • Martijn Schrage
  • Tom Schrijvers (+) (+)
  • Martijn van Steenbergen (+)
  • Jurriën Stutterheim (+)
  • Doaitse Swierstra (+)
  • Wouter Swierstra (+)
  • Jan Terlouw (+)
  • Henk-Jan van Tuyl (+)
  • Alessando Vermeulen (+)
  • Sebastiaan Visser (+)
  • Paul van der Walt (+)
  • Bruce Watson
  • Jaap van der Woude (+)
  • André Zwinkels
  • Arne Weiß (+)
Topic revision: r56 - 06 Aug 2014, AtzeDijkstra

This site is powered by FoswikiCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding UUCS? Send feedback