Nederlandse Functioneel Programmeren Dag 2015


The Dutch Functional Programming Day is an annual gathering of researchers, students, and practitioners sharing a common interest in functional programming. The day features talks that cover the latest advances in research and teaching in the area. Coffee and lunch breaks provide ample opportunity for networking with your colleagues and meeting new people. Experts and newcomers to the field are equally welcome.

The NL-FP day 2015 takes place on Friday, January 9, 2015 at the University of Twente in Enschede.

Contents


Location

The NL-FP Day 2015 takes place at the campus of the University of Twente, in Enschede, in lecture hall "Spiegel-1". See here for a map with relevant locations when travelling to the campus.

There are regular bus services from the train stations of both Enschede and Hengelo: From Enschede, bus lines 1 and 9 leave every 15 minutes from the train station (see 9292OV for detailed information) and from Hengelo, bus line 9 leaves every 15 minutes (see 9292OV for detailed information). Alternatively, travel by train to Enschede Drienerlo, and from there either take bus 1 to the University or walk for about 15 minutes to reach the campus.


Dinner

Dinner will take place at restaurant "Carlina's", Van Lochemstraat 226, Enschede (see map). Those without dietary restrictions will be served the "Optie 2. Hapjesmenu" as described on Group menu.

There will be a bus at 17:45 in front of the Spiegel building that will pick us up and take us to the restaurant.


Programme

A rough sketch of the day, we plan to leave ample room for networking:

09:30 - 10:15 Registration + Coffee
10:15 - 10:20 Welcome and Opening
10:20 - 10:45 Visual languages: functional programming in the era of jab and smoosh
Jelle Hermsen
[abstract] [slides]
10:45 - 11:10 What is Ligretto? A case study in compositional and functional programming
Peter Achten
[abstract] [slides]
11:10 - 11:40 Break
11:40 - 12:05 (CL)S: Combinatory Logic Synthesizer
Jan Bessai
[abstract] [slides]
12:05 - 12:30 t-regex: matching using tree regular expressions
Alejandro Serrano
[abstract] [slides]
12:30 - 14:00 Lunch + Demo/Posters
14:00 - 14:25 Towards more expressive Existential Types: Polymorphic Contexts
Doaitse Swierstra
[abstract] [slides]
14:25 - 14:50 Reflection without Remorse!
Atze van der Ploeg
[abstract] [slides]
14:50 - 15:15 An Embedded Hardware Description Language using Dependent Types
João Pizani
[abstract] [slides]
15:15 - 15:45 Break
15:45 - 16:10 Scala - functional programming on the JVM
Erik Bakker
[abstract] [slides]
16:10 - 16:35 Functional Programming in Swift
Chris Eidhof
[abstract] [slides]
16:35 - 16:45 Closing
16:45 - 17:45 Drinks
18:15 - Dinner

Presentations

Alejandro Serrano - t-regex: matching using tree regular expressions

Abstract: Tree regular expressions provide a general way to describe the shape of tree-like structures, like ADTs found in functional programming languages. In this talk we will see how to integrate these new expressions with your own data types, by using Haskell's support for generic programming. Applications of this library include more powerful pattern matching and extensible attribute grammar-like rules.

João Pizani - An Embedded Hardware Description Language using Dependent Types

Abstract: Formal verification of hardware circuits is growing in prominence, with the accelerating rise in circuit complexity and strict correctness requirements. The use of automated theorem provers based in dependent type theory is a relatively recent phenomenon and shows very promising results when applied to software verification. Therefore, we aim to investigate what benefits can be brought by a Domain-Specific Language (DSL) for hardware description embedded in a language with dependent types. The developed EDSL (Π-Ware) allows for circuits to be modeled and simulated, and for properties to be proven concerning functional correctness and structure.

Peter Achten - What is Ligretto? A case study in compositional and functional programming

Abstract (tentative): How should one define interactive programs in a functional style? This question has been answered many times in many different ways. In this talk we demonstrate a new way of answering this question. Our approach is based on old insights, the most important of which is that a solution must be *purely compositional* as well as new insights, the most important of which is that behaviour should be expressed as tasks in the Task Oriented Programming paradigm.

Chris Eidhof - Functional Programming in Swift

Abstract: In this talk, we'll look at how to do functional programming in Swift. We'll explore both the language and the available APIs.

Jan Bessai - (CL)S: Combinatory Logic Synthesizer

Abstract: The (CL)S Framework implements relativized type inhabitation for Combinatory Logic with Intersection Types. Type inhabitation is a way to automatically construct code from a set of existing well-typed components. This talk will present the goals and some of the applications of the framework. Also its core-architecture and its type system will be explained. We will learn about some of the challenges faced during its development and how these were addressed by its implementation in F# and Scala.

Doaitse Swierstra - Towards more expressive Existential Types: Polymorphic Contexts

Abstract: We will argue that for languages with lazy evaluation the common type systems, and especially the way they deal with existential types, are not sufficiently expressive. We will show how certain useful programs fail to be typed by GHC (but are by UHC). We will also show how to circumvent the lack of expressiveness in GHC.

Atze van der Ploeg - Reflection without Remorse!

Abstract: A well known problem in functional programming is that a ++ (b ++ c) performs better than (a ++ b) ++ c, where ++ is list concatenation. Continuation passing style, in the form of difference lists, solves this problem, but performance problems again arise if we alternate between concatenating and pattern matching on the results of such concatentations. The same problem arises with some monads: m >>= (\x -> f x >>= g) is faster than (m >>= f) >>= g. In this talk, we discuss in which monads this problem arises, and show how to solve such performance problems, even when alternating between binding and observing the results of such binds, which occurs with monadic reflection.

Jelle Hermsen - Visual languages: functional programming in the era of jab and smoosh

Abstract: Why are we still typing our code? We have made the jump from keypunch machines to text terminals, but our programming hasn't fully entered the bird slinging, candy crushing age of touchy swipy goodness. Are programmers the latest luddites or is it impossible to graphically capture the complexity of computing? In this talk we will look at visual programming and especially the way in which a pure functional approach might help create a general-purpose language that is both easy on the eyes and in touch with modern times.

Erik Bakker - Scala: functional programming on the JVM

Abstract: Scala intends to combine FP and OO features on the JVM. But how well does that work? This talk shows how common FP concepts like ADTs and type classes work in Scala, how functions are represented on the 'everything-is-a-class' JVM and some pitfalls when doing functional programming in this language where everything is a subtype of Any.


Contact

Jan Kuper
University of Twente
Computer Architectures for Embedded Systems
Zilverling 5035
PO Box 217
7500 AE Enschede
053 489 3785
j dot kuper at utwente dot nl

Past NL-FP Days

2014 Universiteit van Amsterdam
2013 Radboud Universiteit Nijmegen
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