NL-FP dag 2013

From Clean
(Difference between revisions)
Jump to: navigation, search
Line 265: Line 265:
|51. || Peter Kourzanov || Nee ||
|51. || Peter Kourzanov || Nee ||
|52. || Peter Lebbing || Nee || Universiteit Twente

Revision as of 09:31, 24 December 2012

De Nederlandse Functioneel Programmeren dag 2013 vindt plaats op vrijdag 11 januari 2013 bij de Radboud Universiteit Nijmegen.

Op de NL-FP dag ontmoeten geïnteresseerden in functioneel programmeren elkaar. Gedurende de dag worden een aantal presentaties gehouden over FP-gerelateerde onderzoeksresultaten of over het gebruik van FP in het onderwijs. Daarnaast is er ruime gelegenheid om elkaar te spreken, informatie uit te wisselen, demos te geven en oude bekenden te ontmoeten. De meeste aanwezigen zijn geavanceerde functionele programmeurs, maar beginners zijn natuurlijk ook van harte welkom!


Meld je aan bij Rinus Plasmeijer of Bas Lijnse om een presentatie te geven. Schroom niet om je op te geven, de NL-FP dag is een informele bijeenkomst en ook een prima podium om eigen ervaringen of nieuwe ideeën te delen. Meld je ook aan als je alleen wilt deelnemen, in verband met het reserveren van de lunch. Deelname is gratis.

Traditiegetrouw wordt er na afloop, op eigen kosten, met een groep gegeten. Geef bij je aanmelding aan of je mee wilt gaan eten. Afhankelijk van het aantal deelnemers kan dan een geschikt restaurant gezocht worden.

BELANGRIJK: Als je mee wilt gaan eten geef dat dan uiterlijk maandag 24 december door. Met de groeiende deelnemerslijst moeten we nog voor de jaarwisseling het restaurant gaan reserven.


De NL-FP dag vind in en rond zaal LIN3 in het Linnaeusgebouw (Heyendaalseweg 137) van de Radboud Universiteit. Deze locatie is goed te bereiken per bus (binnen Nijmegen), trein en auto (betaald parkeren). De facultaire reiswijzer geeft je een exacte planning van deur tot deur.


Dit is het voorlopige programma:

09:30 - 10:00 Ontvangst
10:00 - 10:05 Opening
10:05 - 10:30 Clemens Grelck - Functional Programming with Curly Brackets: the SAC Story
10:35 - 11:00 Thomas Arts - Testing AUTOSAR components with QuickCheck
11:00 - 11:30 Koffie en thee
11:30 - 11:55 Anja Niedermeier - Dataflow Inspired Programming Paradigm for Coarse-Grained Reconfigurable Arrays
12:00 - 12:25 Doaitse Swierstra - Compositional Language Definitions
12:30 - 12:40 Ster - (Aankondigingen: Cross Functional Amsterdam Meetup, CEFP2013, IFL2013)
12:40 - 14:00 Lunch
14:00 - 14:25 Bas Lijnse - Reaching the TOP: From workflow combinators to Task-Oriented Programming
14:30 - 14:55 Betsy Pepels - Time Travelling: the philosophy of Functional Programming applied in the wild
15:00 - 15:30 Koffie en thee
15:30 - 15:55 Rinse Wester - Complex hardware design using CλaSH
16:00 - 16:25 Alex Gerdes - Testing webservices with Erlang QuickCheck
16:25 - 16:30 Sluiting
16:30 - 17:30 Borrel
18:30 - Diner



Om alvast een indruk te krijgen van de presentaties zijn hier de abstracts:

Clemens Grelck - Functional Programming with Curly Brackets: the SAC Story

SAC (for Single Assignment C) is in several aspects a functional programming language out of the ordinary. As the name suggests, SAC combines a C-like syntax (with lots of curly brackets) with a state-free, purely functional semantics. Originally motivated to ease adoption by programmers with an imperative background, the choice offers surprising insights into what constitutes a "typical" functional or a "typical" imperative language construct.

Again on the exotic side, SAC does not favour lists and trees, or more generally algebraic data types, but puts all emphasis on multi-dimensional arrays as the primary data structure. Based on a formal array calculus SAC supports declarative array processing in the spirit of interpreted languages such as APL. Array programming treats multidimensional arrays in a holistic way: functions map potentially huge argument array values into result array values following a call-by-value semantics and new array operations are defined by composition of existing ones.

SAC is a high-productivity language for application domains that deal with large collections of data in a computationally intensive way. At the same time SAC also is a high performance language competing with low-level imperative languages through compilation technology. The abstract view on arrays combined with the functional semantics support far-reaching program transformations. A highly optimised runtime system takes care of automatic memory management with an emphasis on immediate reuse. Last not least, the SAC compiler exploits the state-free semantics of SAC and the data-parallel nature of SAC programs for fully compiler-directed acceleration on contemporary multi- and many-core architectures.

Thomas Arts - Testing AUTOSAR components with QuickCheck

The amount of software in a car is growing exponentially. This software has to be produced quickly, differentiate from the competition in functionality, multiplicity of features, and quality. There are several ingredients for enabling this, among them choosing the right technologies, improving the software process, and also being extremely thorough and efficient in testing.

The automotive industry have standardized their components in the AUTOSAR standard. Each component has about 500 pages thorough specification behind it, but many corners can be cut if the car need only part of the features; making the software faster and run on cheaper hardware.

Integration of components from different vendors is a nightmare for car companies. The vast amount of different configurations and scenarios in which the software should operate require an enormous and practically impossible amount of test cases to be written. Smart design of tests is tempting, but it is easy to overlook a corner case or combination one cannot foresee.

We created QuickCheck models for 5 major AUTOSAR components. The models are about 10% of the size of the implementation and condense 1500 pages of specification in 4500 lines of Erlang code. The models take a configuration and software component as input and automatically generate and run thousands of tests against that component. We have been able to find anomalies in all provided, well tested, software components. We cover many more scenarios and tricky combinations than manual test cases are able to cover. Moreover, we can re-use the model for any given implementation and configuration.

With this technology we can increase test efficiency dramatically, find more errors and only invest a fraction of what it takes to write manual test cases.

Anja Niedermeier - Dataflow Inspired Programming Paradigm for Coarse-Grained Reconfigurable Arrays

Many algorithms that are common in digital signal processing (DSP), such as video streaming, contain a high degree of instruction-level parallelism. To accelerate such algorithms, coarse-grained reconfigurable architectures (CGRA) can be used.

In practise, many existing DSP algorithms are implemented in a sequential way, and extracting the instruction level parallelism from these algorithms is not trivial.

Here we present a programming paradigm for expressing instruction-level parallelism at a high level. The programming paradigm was implemented leading to a compiler for a previously developed CGRA. Both the compiler and the architecture were implemented using the functional programming language Haskell. This allows algorithms to be implemented in a concise and straight-forward matter by using Haskell's higher order functions. As these functions have a notion of structure, all information on parallelism and flow of data is automatically contained in the resulting expressions as we demonstrate on a few examples.

Doaitse Swierstra (and Marcos Viera) - Compositional Language Definitions

Over the years we have been developing Haskell libraries which enable one to define a compiler as a large collection of components, which can be individually type checked and compiled into machine code. The final compiler then consists of a small program which imports these modules and combines them. The Haskell type checker then checks whether the collection is consistent.

In the talk we will show how we have used our libraries to solve the challenges set in a competition organised bij de LDTA workshop, which can be found at: A combination of n tasks and m language levels gives in our solution rise to m*n independent components.

A technical report describing the solution can be found at, and will be a part of Marcos Viera's upcoming thesis (which we hope will be defended at March 8, 16:15).

Bas Lijnse - Reaching the TOP: From workflow combinators to Task-Oriented Programming

Volgt zo spoedig mogelijk...

Betsy Pepels - Time Travelling: the philosophy of Functional Programming applied in the wild

The Dutch Tax and Customs Administration is responsible for the implementation of income-related schemes, known as benefits. For the calculation and payment of these benefits, a newly built system is in production since December 2011. This Benefits system runs on the Microsoft.NET Framework using C# as the implementation language.

An important feature of the Benefits application is Time Travelling. This is the ability to do computations with and to travel within the three different time axes present in the Benefits domain. These axes are the valid time (keeping track of the situation of a citizen), the report time (keeping track of when information is reported) and the transaction time (keeping track of when information is recorded).

Our group accomplished Time Travelling by a clever combination of several concepts. The application is defined in a dedicated DSL in which the objects and computations are basically untimed. The core idea is domain lifting (which we gratefully borrowed from the Functional Programming world): the untimed DSL is “under the hood” lifted to a timed domain. This is done by translating the DSL via code generators to a timed internal DSL. Finally, FP features of C# (most notably LINQ, lambda expressions and extension methods) facilitate the implementation of the internal DSL.

Rinse Wester - Complex hardware design using CλaSH

In order to effectively utilize the growing number of resources avail- able on FPGAs, higher level abstraction mechanisms are needed to deal with the increasing complexity resulting from large designs. Functional hardware description languages, like the CλaSH HDL, offer adequate abstraction mechanisms such as polymorphism and higher-order functions to address this problem.

A two step design method to implement a complex DSP application on an FPGA is presented, starting from a mathematical specification, followed by an implementation in CλaSH. A particle filter is chosen as application to be implemented.

First, a straightforward translation is performed from the mathematical definition of a particle filter to plain Haskell. Secondly, minor changes are applied to the Haskell implementation so that it is accepted by the CλaSH compiler and hardware can be generated. The resulting hard- ware produced by this method is evaluated and shows that this method eases reasoning about structure and parallelism in both the mathematical definition and the resulting hardware.

Alex Gerdes - Testing webservices with Erlang QuickCheck

More and more applications are made available as web applications, which run in a web browser. A web application often makes use of web services. These web applications rely on the quality of those web services. It is important to assess the quality of the web services as well as the overall quality of the web application. One way of assessing the quality of a web application or a web service is to test if it displays the expected behaviour. In this talk we show how we use Erlang QuickCheck to test web applications and web services. We do so by modeling a web application in QuickCheck, state properties that the web application should have, and test whether these properties hold. We use the Dudle web application as an example to show how our approach works. Dudle is an open-source version of the popular Doodle web application.


Nr Naam Diner Organisatie
1. Rinus Plasmeijer Ja Radboud Universiteit Nijmegen
2. Bas Lijnse Ja Radboud Universiteit Nijmegen
3. Doaitse Swierstra Ja Universiteit Utrecht
4. Jurriën Stutterheim Ja Universiteit Utrecht
5. Betsy Pepels Ja Tax and Customs Administration
6. Albert Schrijvers Ja Tax and Customs Administration
7. Ruud Koot Ja Universiteit Utrecht
8. Vadim Zaytsev Ja Centrum Wiskunde & Informatica
9. Johan Jeuring Ja Universiteit Utrecht
10. Steffen Michels Ja Radboud Universiteit Nijmegen
11. Michel Rijnders Ja TTY Internet Solutions
12. Matthijs Ooms Ja TTY Internet Solutions
13. Christiaan Baaij Ja Universiteit Twente
14. Maarten Hoogendoorn Ja
15. Gabe Dijkstra Ja Universiteit Utrecht
16. Sander van den Berg Nee Xebia
17. Jan Martin Jansen Onbekend Nederlandse Defensie Academie
18. Pieter Koopman Nee Radboud Universiteit Nijmegen
19. Alex Gerdes Ja QuviQ
20. Thomas Arts Ja QuviQ
21. Jan Kuper Ja Universiteit Twente
22. Anja Niedermeier Ja Universiteit Twente
23. Rinse Wester Ja Universiteit Twente
24. Atze Dijkstra Ja Universiteit Utrecht
25. Arjen van Weelden Onbekend
26. Bas Dirks Ja
27. Clemens Grelck Nee Universiteit van Amsterdam
28. Tom Lokhorst Ja Q42
29. Paul Visschers Ja Q42
30. Martijn van Steenbergen Ja Q42
31. Sjoerd Visscher Ja Q42
32. Willem Prakken Nee Saxion
33. Jeroen Bransen Nee Universiteit Utrecht
34. Cyril Schmidt Ja Alluve
35. Jan Rochel Jan
36. Arjan Boeijink Ja Universiteit Twente
37. Pepijn Kokke Onbekend
38. Wout Elsinghorst Ja Universiteit Utrecht
39. Wouter Swierstra Ja Universiteit Utrecht
40. Henk-Jan van Tuyl Ja Van Tuyl Software
41. Gerald Otter Ja Universiteit Twente
42. Matthijs Kooijman Ja
42. Maarten Fokkinga Nee Universiteit Twente
43. Alessandro Vermeulen Ja Universiteit Utrecht
44. Anton Golov Ja Universiteit Utrecht
45. Bastiaan Heeren Ja Open Universiteit
46. Jan-Willem Roorda Onbekend Intel
47. Wim Yedema Onbekend Intel
48. João Paulo Pizani Flor Nee Universiteit Utrecht
49. Jack Klappe Ja Open Universiteit
50. Peter Achten Ja Radboud Universiteit Nijmegen
51. Peter Kourzanov Nee
52. Peter Lebbing Nee Universiteit Twente

Vorige NL-FP dagen

2012, Universiteit Utrecht
2011, Universiteit Twente, Enschede
2010, Radboud Universiteit Nijmegen
2009, Technische Universiteit Eindhoven
2008, Open Universiteit Utrecht
2007, Marine, Amsterdam
2006, Hogeschool Avans, Breda
2005, Rijksuniversiteit Groningen
2004, Universiteit Twente, Enschede
2003, Universiteit Utrecht
2002, Katholieke Universiteit Nijmegen
2001, Technische Universiteit Delft
2000, Technische Universiteit Eindhoven
1999, Hogeschool Breda
1998, RijksUniversiteit Leiden
1997, Hogeschool Leeuwarden
1996, Universiteit van Amsterdam
1995, Technische Universiteit Twente, Enschede
1994, Rijksuniversiteit Utrecht
1993, Katholieke Universiteit Nijmegen
Personal tools