[ Nederlands ] [ English ]

22nd NL-FP Day 2014

The Netherlands Functional Programming Day 2014 took place on Friday, January 10, at the University of Amsterdam. The NL-FP Day is an annual gathering of scientists, students and practitioners who share a common interest in functional (declarative) programming. The day features a string of talks covering the latest advances in research and teaching in the area. Coffee and lunch breaks provide ample opportunity for networking with your colleagues just as for meeting new people. Experts and novices are welcome alike.

The next Netherlands Functional Programming Day will take place on Friday, January 9, 2015 at University of Twente.

Contents

• Registration
• Location
• Dinner
• Programme
• Participants
• Presentations
• Contact
• Previous NL-FP Days

Registration

Register by email to Clemens Grelck. Please, indicate if you would like to give a presentation. If so, a tentative title would be welcome; of course this could still be changed later. Don't be shy! The NL-FP day is an excellent opportunity to present your ideas in an informal and friendly atmosphere. Presentation or not, register your participation as soon as possible so that we can plan ahead for lunch and coffee breaks.

Note: As the programme has been finalised in the mean time, I'm no longer soliciting proposals for presentations.

The registration fee is 25EUR to cover the cost of catering during the day. Please, pay in cash on arrival; receipts will be issued.

Traditionally, the NL-FP day ends with a joint dinner in a nearby restaurant (at your own cost). Please, indicate upon registration whether or not you would like to join for dinner. The choice of restaurant depends on the size of the group. IMPORTANT: if you intend to join for dinner, let us know by January 5 at the very latest, or we may not be able to accommodate you.

Location

The NL-FP day takes place in lecture hall C0.05 in the new building of the Science Faculty (below left, bulding 904) at Science Park Amsterdam. Science Park Amsterdam can easily be reached by NS train (station Amsterdam Science Park (below right) as well as by GVB bus. The sprinter services Zwolle-Weesp-Amsterdam Centraal and Hoofdorp-Schiphol-Amsterdam Centraal-Weesp-Amersfoort bot run half hourly and create quaterly connections between Amsterdam Centraal and Weesp/Amersfoort. Bus lines 40 and 240 from Amstel station and bus line 40 from Muiderpoort station run quaterly each and connect Science Park to the rest of Amsterdam's public transport system as well as to train services to and from Utrecht and Gouda (via Amstel station).

Limited public parking facilities are available at Science Park, but parking is fairly expensive (expect around 20 EUR for the day).

Dinner

The joint dinner will take place at de ponteneur. This eetcafe/restaurant is less than 5 minutes walk from Amsterdam Muiderpoort train station, with frequent connections to Amsterdam Centraal, Utrecht and Amersfoort. At the end of the programme we will jointly walk there (about 20 minutes). The 3-course set dinner with meat, fish and vegetarian options is 25.50 plus drinks.

Programme

Participants

Presentations

Jose Pedro Magalhaes: Advanced Functional Programming for Fun and Profit

Abstract: Functional programming, especially when using advanced techniques such as GADTs, type functions, and kind polymorphism, is not only fun; it can also be profitable. In this talk I'll describe my experience in using advanced functional programming in Haskell within Chordify, a web startup that brings chord recognition to the masses.

Vadim Zaytsev: Imperative and Declarative Views on Software Language Evolution

Abstract: Software languages generalise programming languages and allow us to use the same or extended methods on markup languages, DSLs, ADTs, APIs, data schemata, etc. In particular, for many software languages their evolution is an even more important aspect than it is for classic programming languages. By researching software language evolution imperatively, we consider several 'snapshot' instances of language definitions (grammars in a broad sense), which are usually easy to obtain. By looking at software language evolution declaratively, we consider its encoding as grammar transformation steps, which express the evolution intent more precisely. In this talk, you will hear both sides of the story and get an overview of advantages and drawbacks of both.

Jurrien Stutterheim: Tonic: Task Oriented Notation Inferred from Code

Abstract: In this talk we present Tonic, a system for visually gaining insight in iTasks programs’ structure and behaviour. Tonic helps non-programmers to understand iTasks programs by automatically generating a visual representation of a program at compile-time and aims to provide live runtime information while a program is executing.

Jacco Krijnen: Expand: Towards an Extensible Pandoc

Abstract: The Pandoc program is a versatile tool for converting between document formats. It comes with a great variety of readers, each converting a specific input format into the universal Pandoc format, and a great variety of writers, each mapping a document represented in this universal format onto a specific output format. Unfortunately the intermediate Pandoc format is fixed, which implies that a new, unforeseen document element cannot be added. In this paper we propose a more flexible approach, using our collection of Haskell libraries for constructing extensible parsers and attribute grammars. Both the parsing and the unparsing of a specific document can be constructed out of a collection of precompiled descriptions of document elements written in Haskell. This collection can be extended by any user, without having to touch existing code. The Haskell type system is used to enforce that each component is well defined, and to verify that the composition of a collection components is consistent, i.e. that features needed by a component have been defined by that component or any of the other components. In this way we can get back the flexibility e.g. offered by the packages in the LaTeX package eco-system.

Patrick Bahr: Calculating Correct Compilers

Abstract: We present a new approach to the longstanding problem of calculating compilers. In particular, we develop a simple but general recipe that allows us to derive correct compilers from high-level semantics by systematic calculation, with all the required compilation machinery falling naturally out of the calculation process. Our approach is based upon a new application of well-known transformation techniques, and has been applied to calculate compilers for a wide range of language features and their combination, including arithmetic, exceptions, local and global state, various forms of lambda calculi, bounded and unbounded loops, non-determinism, and interrupts.

Peter Kourzanov: Structure and Interpretation of Definite Clause Grammars

Abstract: Definite clause grammars (DCG) is a technique that allows one to embed a parser for a context-sensitive language into logic programming, via Horn clauses. A carefully designed grammar parser can be run forwards, backwards and sideways. In this talk we shall de-construct DCGs using syntax-rules and miniKanren, a library for R5RS Scheme implementing a compact logic-programming system, keeping reversibility in mind. Parsing expression grammars (PEG) is a related technique that like DCG also suffers from the inability to express left-recursive grammars. We make a link between DCGs and PEGs by borrowing the mechanism from DCGs, adding syntactic sugar from PEGs and propose a way to run left-recursive parsers in an on-line fashion. Finally, we re-interpret DCGs as executable, bidirectional DSL specifications and transformations, perhaps better suited for DSL design than R5RS syntax-rules.

Michal Gajda: Fastest Protein Data Bank Parser on Earth is Written in Haskell

Abstract: Protein Data Bank file format is used for the majority of biomolecular data available today. I have written a high level library for processing biomolecular data in this format. The benchmarks indicate that the library is competitive to the other frequently used Protein Data Bank parsing software on a single core, and much faster when used on multicore. It also features a convenient iterator mechanism, and a simple API modeled after BioPython I will also shortly present current status of the BioHaskell effort to build bioinformatic libraries for Haskell.

Tijs van der Storm: Rascal: Functional Programming for Source Code Analysis and Transformation

Abstract: Rascal is a meta programming language developed at CWI. It has been specifically designed for transforming and analyzing source code. This includes applications like static analysis, source code metrics computation, legacy renovation and implementation of domain-specific language compilers, type checkers and IDEs. In this talk I will introduce the language and some its more notable features, including built-in context-free grammars, a wide range of built-in data types, primitives for tree traversal, and powerful constructs for pattern matching. Time permitting I'll demonstrate the language and environment using the example of a simple DSL for state machines.

Arjan Boeijink: Keeping the PilGRIM at a Steady Pace: Avoiding Pipeline Stalls in a Lazy Functional Processor

Abstract: The PilGRIM (Pipelined Graph Reduction Instruction Machine) is a processor design with a high level instruction set specialized for functional languages. With the PilGRIM we attempt to exploit the potential of modern hardware architecture to minimize the overhead of executing functional languages. Execution of lazy functional programs is both memory and control flow intensive, which makes it challenging to keep a deep pipeline filled with useful work. This talk will introduce the core ideas of the PilGRIM design, and show how the high level instruction set and extra runtime information can be used to avoid many pipeline stalls.

Raphael Poss: Compositional Hardware Virtualization

Abstract: Abstractions that hide hardware away from programming are useful in that they allow the programmer to concentrate on "more important" tasks, such as decomposing problems, expressing them in exact semantics, and proving that implementation matches specification. Nevertheless the syntactic variance problem still exists: in any functional language, there are multiple ways to write the same function which cannot be automatically optimized from one to another. One of them will be "better" for extra-functional reasons, more often than not performance and efficiency. But how to determine this? In this talk, I will propose that compositional hardware virtualization, a notion I will describe, is a fundamental building block of the operational intuition that functional programmers unconsciously use when choosing between different candidate function implementations.

Lesley Wevers: Optimizing Transaction Execution in a Purely Functional Database: Towards Database Maintenance without Downtime

Abstract: Current database systems needs to be taken offline to perform major changes. This is of course not acceptable for applications that need to be available at all times. We are developing a new kind of database system based on functional languages, where we use techniques such as laziness and memoization to optimize database transactions in ways not possible in traditional database systems. Using these techniques, we want to make it possible to perform database maintenance without downtime.

Tom Ellis: Opaleye: an Embedded Relational Query Language for Haskell

Abstract: Opaleye is a relational query language embedded domain specific language for Haskell, which compiles to SQL and can run against a PostgreSQL database server. It has some similarity to HaskellDB, but is based on a firm theory derived from category theoretical principles, and therefore avoids bugs that HaskellDB suffers. I will give a brief introduction to the library and the technology behind it.

Contact

Previous NL-FP Days