NL-FP dag 2013

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! Aanmelden 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. Locatie 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. Diner Het diner is gereserveerd bij eetcafe "de Serre". We krijgen daar "meze" geserveerd. Een selectie van kleine turkse gerechtjes. De Serre ligt schuin tegenover het centraal station en is daarmee ideaal met het openbaar vervoer te bereiken. Omdat we bijna het volledige restaurant bezetten kunnen we voor late aanmeldingen (als er nog geen "Ja" achter je naam op de lijst staat) geen plaats garanderen. Laat het wel weten als je alsnog mee zou willen zodat je op de reservelijst komt en we kunnen kijken wat mogelijk is. Laat het ook weten als je besluit toch niet mee te gaan, zodat we weten dat er plaats is voor mensen op de reservelijst. Programma 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:15 Borrel 18:00 - Diner

Presentaties

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: http://ldta.info/tool.html. 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 http://www.cs.uu.nl/research/techreps/UU-CS-2012-016.html, 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.

Deelnemers

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	Nee	Nederlandse Defensie Academie
18.	Pieter Koopman	Nee	Radboud Universiteit Nijmegen
19.	Alex Gerdes	Ja	QuviQ
20.	Thomas Arts	Ja	QuviQ
21.	Jan Kuper	Nee	Universiteit Twente
22.	Anja Niedermeier	Ja	Universiteit Twente
23.	Rinse Wester	Ja	Universiteit Twente
24.	Atze Dijkstra	Nee	Universiteit Utrecht
25.	Arjen van Weelden	Nee
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	Ja
36.	Arjan Boeijink	Ja	Universiteit Twente
37.	Pepijn Kokke	Nee
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	Nee	Intel
47.	Wim Yedema	Nee	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
53.	Jeroen Henrix	Ja
54.	Jeroen Leeuwestein	Ja
55.	Wessel van Staal	Nee	Radboud Universiteit Nijmegen
56.	Martijn Schrage	Nee	Oblomov Systems
57.	Thomas van Noort	Nee	Silk

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