This section presents details about the

Invited Lectures

Edwin Brady: Embedded Domain Specific Languages with Dependent Types

Types describe a program’s meaning. Dependent types, which allow types to be predicated on values, allow a program to be given a more precise type, and thus a more precise meaning. Typechecking amounts to verifying that the implementation of a program matches its intended meaning. In these lectures, I will introduce the Idris language, a pure functional programming language with dependent types. Idris has several features intended to support domain specific language development, including syntax extensions, overloadable binders and implicit conversions. I will show, by example, how dependent types can be used to express program properties, how resources such as file handlers and network protocols may be managed through embedded DSLs, and finally give a general framework for programming and reasoning about side-effects, implemented as an embedded DSL.

Marco Danelutto: Structured parallel programming in FastFlow

We introduce the structured parallel programming framework FastFlow and we discuss problems and issues related to structured parallel programming framework implementation. In particular we will discuss: - algorithmic skeleton approaches and the associated static (template based) or dynamic (macro data flow based) implementation technologies - autonomic management of non functional features, with particular focus on performance and fault tolerance - different optimizations aimed at targeting COW/NOWs and shared memory multicores - heterogeneous architecture targeting (including GPUs).

Gergely Dévai, Máté Tejfel, Dániel Leskó: The EDSLs’ struggle for their sources

Embedding is a powerful technique to speed up the domain specific language creation process. On the other hand, accessing information about the source code in EDSL compilation time is hard. This lecture of the summer school will first explain the root of the problem and show its consequences, then discuss possible solutions like different preprocessing options and the combination of embedding and parsing. Evaluation of the methods is based on experience from industrial research projects on EDSLs using Haskell as the host language.

Jeremy Gibbons: FP for Domain-Specific Languages

Domain-specific languages become effective only in the presence of convenient lightweight tools for defining, implementing, and optimizing new languages. Functional programming provides a promising framework for such tasks; FP and DSLs are natural partners. In these lectures we will discuss FP techniques for DSLs - especially standalone versus embedded DSLs, and shallow versus deep embeddings.

Ádám Granicz: Functional Web and Mobile Development in F#

In this talk I will discuss how functional programming and F# in particular can be applied to develop web and web-based mobile applications using WebSharper, a mature open-source web and mobile development framework for F#.
You will learn about markup combinators, type-safe and composable web forms and sitelets, and why these functional abstractions enable robust, rapid and effective development.

Kevin Hammond: Forming Parallel Haskell Programs using Novel Refactoring Techniques

Despite Moore’s “law”, uniprocessor clock speeds have now stalled. Rather than using single processors running at ever higher clock speeds, it is common to find dual-, quad- or even hexa-core processors, even in consumer laptops and desktops. Future hardware will not be slightly parallel, however, as in today’s multicore systems, but will be massively parallel, with manycore and perhaps even megacore systems becoming mainstream. This means that programmers need to start thinking parallel. To achieve this they must move away from traditional programming models and development processes that offer parallelism as an bolted-on afterthought.

This talk introduces the idea of “paraforming”, a new approach to constructing parallel functional programs using formally-defined refactoring transformations. We show how parallel programs can be built from a small number of primitive Haskell building blocks, and describe some new refactorings for Parallel Haskell that capture common parallel abstractions, such as divide-and-conquer and data parallelism using these building blocks. Using a paraforming approach, we are able to easily obtain significant and scalable speedups (up to 7.8 on an 8-core machine).

Jan Kuper: Hardware design with CλaSH

CλaSH is a hardware specification language, which models digital circuits directly as functions transforming input signals into output signals, where functions can be stateful. CλaSH is based on the functional programming language Haskell, and offers abstraction mechanisms which are far more powerful than traditional hardware description language. Examples of these abstraction mechanisms are polymorphism, higher order functions, lambda abstraction, type derivation, arrow composition. These features lead to concise and readable specifications of hardware architectures. An important feature of CλaSH is that the full process of hardware development – including problem definition, architecture specification, simulation – takes place in the same environment. Experience has shown that designer productivity increases substantially when using CλaSH.

Rinus Plasmeijer: Task-Oriented Programming

Task-Oriented Programming (TOP) is a novel programming paradigm for the construction of distributed systems where users work together on the internet. When multiple users collaborate, one needs to interact with each other frequently. TOP supports the definition of tasks that react on the progress made by others. With TOP, complex multi-user interactions can be programmed in a declarative style just by defining the tasks that have to be accomplished, thus eliminating the need to worry about the implementation detail that commonly frustrates the development of applications for this domain.

Zoltán Porkoláb: DSL in C++ template metaprogram

We discuss a DSL integration technique for the C++ programming language. The solution is based on compile-time parsing of the DSL code. The parser generator is a C++ template metaprogram reimplementation of a runtime Haskell parser generator library. The full parsing phase is executed when the host program is compiled. The library uses only standard C++ language features, thus our solution is highly portable. As a demonstration of the power of this approach, we present a highly efficient and type-safe version of printf and the way it can be constructed using our library. Despite the well known syntactical difficulties of C++ template metaprograms, building embedded languages using our library leads to self-documenting C++ source code.

Joao Saraiva: SpreadSheet Engineering

In this tutorial we present our work on spreadsheet engineering. We start by presenting a model-driven spreadsheet development environment (MDSDE), where a domain specific spreadsheet model is used to guide end-users in introducing correct data. The business logic of spreadsheet data is modelled via domain specific classSheet models. End users can not only (traditionally) edit/update the spreadsheet data, but also to evolve the model and/or the data. Our MDSDE automatically guarantees model/instance synchronization after a model/instance evolution.

Invited lectures from our industrial partners

András Vajda: Using functional languages for programming multi-core processors

Andras Vajda is expert in cloud computing within Ericsson’s global cloud computing program, focusing on the complete operational and business support system stack for Ericsson’s offering. Previously, Vajda held positions within Ericsson Research and the Networks business unit. Within Ericsson Research he was one of the initiators of Ericsson’s cloud research efforts, driving the strategy and architecture work; he was also responsible for co-ordinating Ericsson’s software research activities and the interaction with external parties in the area of many-core programming. At the business unit Networks he was the chief architect of the Ericsson Gateway for Mobile Networks and contributed to the development of other network elements, such as the 3G Radio Network Controller. Vajda represents Ericsson in the steering groups of several international and national initiatives, such as the European Network of Excellence for High-Performance Embedded Architecture and Compilers (HIPEAC,

He is the author of the book “Programming Many-core Chips”, published by Springer in 2011.

Alexandru Keszeg (PITECH+PLUS, Software Developer): Testing in Ruby

In this talk I will discuss how libraries in Ruby leverage the language to enable clear, concise and readable code. I will focus on the RSpec gem, a behavior-driven development (BDD) framework. BDD is an approach to software development that combines Test-Driven Development, Domain Driven Design, and Acceptance Test-Driven Planning. RSpec helps you do the TDD part of that equation, focusing on the documentation and design aspects of TDD.