Speakers

Thursday Opening Keynote: Implicits Revisited

I’ll talk about the history of Scala’s implicits: how they evolved, some mistakes we could have avoided in hindsight, as well as aspects I believe we got right. I then present the revised implicit design of Scala 3 and explain how it addresses the problems mentioned earlier.

Keynote: A categorical view of computational effects

Closing Keynote: Thinking Like a Data Scientist

The field of data science, which has an increasingly profound impact on our lives, is meanwhile in the middle of an identity crisis. The fundamental questions of what data science is, who is a data scientist, and how do we best do data science to serve society, remain largely undecided. Regardless of where the answers will fall, there are a number of tools, techniques, and ways of thinking that every data scientist should have in their toolbelt. Although the software languages, frameworks, and algorithms will come in and out of fashion, the fundamentals behind the trade have existed for centuries and will continue to be used for ages to come.

What FP Can Learn From Static Introspection

What if compile time and type level programming in functional programming languages were easy, something you reach for without even thinking about it? What if you could debug type errors with a simple compile time print statement? Write highly flexible systems by being able to introspect into types at compile time? Pre-calculate large portions of your programs for great efficiency?

Typed functional programming is a great and fun way to write resilient software, and as type systems have become more and more expressive in recent years, we are able to program sophisticated and useful properties at the type level for even better compile time safety. Just one problem: It is very difficult, requires advanced knowledge of the type system, the syntax is convoluted, the error messages are impenetrable, and it is nearly impossible to debug.

This talk will dive into why we should steal static introspection from languages like Nim, and D, state-of-the-art imperative programming languages which can solve all these issues, make type systems much more approachable without losing any expressive power, and offer new design possibilities for functional programs.

So I used Erlang . . . is my system as scalable as they say it'd be?

In the world of distributed, highly concurrent and scalable systems, few technologies can live up to Erlang/OTP's potential. But, as we often hear, with great power comes great responsibility . . . What if we have designed the architecture of our background to be scalable and used Erlang/OTP to implement it? What now? Should we go straight ahead and jump into the production pool?

Sit and wait for thousands, millions of requests to come? In this talk, we'll see how we can test the robustness of our system in a controlled setting, and in an automated, effective way. Using ProER, a property-based testing tool that follows into the footsteps of the famous QuickCheck, we will see how our software's validation can be both a challenge and a cool task, when we put the right tools in practice.

Time-sensitive protocol: Links From Design to Implementation

This talk will centre on developing systems where distributed components interact via asynchronous message passing, and need to follow specific interaction patterns, e.g., ad-hoc application-level protocols, such as POP2.

I will discuss ongoing work towards establishing relationships between protocols and their implementations, focussing on time-sensitive protocols, where interactions are associated to time-constraints. We will look at two (partly-related) formal ways of describing protocols: Timed Session Types and Automata.

Session Types are a powerful and effective technique for program verification; they allow to type-check programs against their communication behaviour, other than on the type of the messages. For Timed Automata, the relationship between protocols and (abstractions of) programs can be expressed as a refinement relation between more and less abstract models, giving concrete guidelines on how to implement timed protocols while preserving the intended behaviour and progress.

I will discuss recent theories, learnings, open challenges, and future directions.

What the F(p) is Kotlin?

We, as two entry level engineers, took on the challenge of introducing Kotlin and Functional Programming to our company, Intuit. Even though you all know Kotlin is a great language, we overcame the obstacles associated with a large company structure of having a common tech stack. In addition, Kotlin provided a natural transition for OOP Java developers to use Functional Programming Paradigms.

Hear about how, in less than two years, we went from getting our diplomas to gaining influence and driving change at a major technology company, and how you can do it too.

What the F(p) is Kotlin?

We, as two entry level engineers, took on the challenge of introducing Kotlin and Functional Programming to our company, Intuit. Even though you all know Kotlin is a great language, we overcame the obstacles associated with a large company structure of having a common tech stack. In addition, Kotlin provided a natural transition for OOP Java developers to use Functional Programming Paradigms.

Hear about how, in less than two years, we went from getting our diplomas to gaining influence and driving change at a major technology company, and how you can do it too.

Language-Oriented Programming with Racket

Racket, a functional language in the Lisp family, promotes a language-oriented style of programming. Developers create many domain-specific languages, write programs in those, and compose these programs via Racket code. This style of programming can work only if creating and composing little languages is simple and effective. This talk will demonstrate how Racket achieves this goal, starting from bare-bones functional code and moving through a range of examples from classical research (Algol '60) to modern end-point programming for the Web.

Optimising your code with math

In general, we don’t know much about our functions other than their potential associativity. But what if we knew more about them? In this talk, you will learn how to use algebraic properties of functions, data types and effects to improve the performance of your programs.

Functional Smart Contracts

Functional programming and blockchains are a match made in heaven! The immutable and reproducible nature of distributed ledgers is mirrored in the semantic foundation of functional programming. Moreover, the concurrent and distributed operation calls for a programming model that carefully controls shared mutable state and side effects. Finally, the high financial stakes often associated with blockchains suggest the need for high assurance software and formal methods.

Nevertheless, most existing blockchains favour an object-oriented, imperative approach in both their implementation as well as in the contract programming layer that provides user-defined custom functionality on top of the basic ledger. On the one hand, this might appear surprising, given that it is widely understood that this style of programming is particularly risky in concurrent and distributed systems. On the other hand, blockchains are still in their infancy and little research has been conducted into associated programming language technology.

In this talk, I will explain the connection between blockchains and functional programming and argue that blockchains are a well-suited application area for functional programming techniques. I will illustrate this with evidence from the research-driven development of the Cardano blockchain and its contract programming platform, Plutus. Cardano and Plutus are implemented in Haskell and Rust, and the development process includes semi-formal specifications together with mechanised theorem proving to formalise key components.

The Reason for ReasonML

JavaScript is a critical part of today's programming landscape, and not just for web applications. However, its lack of static typing has given lots of developers grief over the years as they struggled with cryptic runtime error messages such as 'cannot find property X of undefined' (I've been there, too). With the introduction of ReasonML, we're now able to write statically typed, simpler and faster JavaScript. In this talk, we'll cover what ReasonML is, what it isn't, why it's worth paying attention to, how it works, and how it can be used in your applications.

Refactoring Recursion

Recursion is the fundamental looping mechanism in functional programming. This talk shows patterns of recursion using Haskell. It shows those patterns for list structure only. This makes it easier for beginners to understand recursion schemes by focusing on their operation with lists. We start by writing explicit recursive versions of sum, product, and length of lists, then factor them into fold functions. We proceed in a similar manner with other folds, unfolds, and refolds with many examples of the patterns in operation. We end by mentioning factoring recursion out of data.

Fun With Categories

Category theory provides us the setting and a common language to talk about computation and composition. Its usage pervades and inspires languages such as Haskell and Scala, lending concepts like functors and monads. Still, functional programming is just one of the possible applications of category theory, which may actually vary from physics and chemistry to machine learning and blockchain. So what about a change of perspective? Let's make category theory the subject of our code and actually implement it!

In this talk, we will take a look at how we can define concepts of category theory, using a programming language as Idris, which allows us to properly define all the required laws and properties of the objects in question, and we will see how we can take advantage of them in concrete contexts.

A Series of Unfortunate Effects

The very essence of functional programming relies on a fairly simple premise: write side-effectless programs, so that you can reason about them equationally. Side-effects however are predominant in every program that . . . well, does something useful. In light of this, the modelling of effects in functional programs has become a fairly active domain of study. From stacked effects, to horizontal ones; from transformers to free monads and so on. Every effect model, though joyfully they may seem, have some rather unfortunate consequences. In this talk, I'd like to share with you some of these effect models and exemplify both their joyful and unfortunate nature.

Hands-On ZIO

ZIO is a library for asynchronous and concurrent programming in Scala, which shows the power of pure functional programming to solve business problems. In this hands-on workshop, you'll learn why it's time to upgrade your Future or Akka-based code to ZIO, and how doing so will give you an unprecedented ability to rapidly build asynchronous and concurrent applications that are resilient, testable, type-safe, debuggable, and performant.

• Introduction to functional effects
• Creation and composition
• Error management
• Thread management
• Asynchronous programming
• Concurrent programming
• Testability
• Debugging

Writing Programs That Write Tests: Better Testing With Scala

Writing tests is so . . . boring. And repetitive. And often, in hindsight, rather ad hoc, and therefore ineffective. We'll learn about property-based testing using ScalaCheck: How it compares to unit testing, when is it better (or worse); learning about different families of invariants and when they are appropriate for your code; how to structure the tests using the main ScalaCheck abstractions, run them, and debug them; and how to test stateful systems. Don't write tests! Write code that will write lots of tests!

Attendees will learn:

• The differences between property-based testing and traditional unit testing
• How to recognize the most common kinds of properties and encode them
• How to structure, or refactor, existing tests using ScalaCheck
• Debugging strategies for tests
• Testing strategies for stateful systems

Main audience: developers familiar with traditional unit testing who want to learn more powerful techniques.

The Ins and Outs of Generic Programming

Generic Programming is the technique of writing programs that works over a class of arbitrary data types. That is how automatic toJSON and fromJSON are implemented in Haskell, for instance. They work by induction on the datatype they are translating to or from JSON. The variety of ways of writing generic programs can be daunting, each coming with their own pros and cons. In this workshop, I will outline the ins and outs of some libraries. We will look into the trade offs and examples of each approach, including some state-of-the-art techniques. We start the journey with GHC.Generics, go into Generics.SOP, and finish at Generics.MRSOP. We will cover simple examples such as generic serialization well into more complicated ones such as generic unification. These will require us to fiddle with the representation of our types and perform some operations such as annotating a recursive datatype and adding holes to a datatype in a generic fashion, which are useful in practice.

During this workshop I will walk the participants through a number of hands-on generic programming exercises aimed at teaching them a number of useful techniques which show up in practice. I expect the attendees to have some intermediate-level Haskell experience and a working Haskell distribution on their computers.

We will look into three main flavors of generic programming over regular data types and we will talk about more advanced concepts such as GADTs and Mutually Recursive families if time allows.

I will walk the participants through a number of generic algorithms, where they will be implementing a significant part of the algorithms below. The boilerplate code and stack.yaml file will be provided by me. Ideally, I would like to cover:

• Generic Equality
• Generic Serialization
• Generic Merkle Trees (which involve annotated fixpoints)
• Generic Unification (which involve adding holes to the types in question)
• Testing strategies for stateful systems

Getting Started: You need to have stack installed. You can get it here. In order to speed up the setup during the workshop, please clone this repo somewhere and run stack build on the root.

Hands-on With SAFE Stack

SAFE Stack (https://safe-stack.github.io) allows the creation of end-to-end F# web apps. Bootstrap fast using an advanced dotnet template. Use the power of F# to build outstanding client-side logic without even touching JS! Extract common code to reuse between client and server. Deploy to a selected cloud provider using built-in supporting scripts. During this workshop, we'll build up a complete, full-stack TodoMVC (http://todomvc.com/) web application We'll do that by starting from a pre-configured skeleton and progressing through adding new features as we go. To prepare for the workshop please install prerequisites and get the skeleton application running as per instructions: SAFE TodoMVC Workshop

Yin and Yang of Haskell by 47 Degrees

In this full-day workshop, you have the chance to learn how to design and build applications using Haskell, one of the better-known functional languages. Haskell shines in describing business domains in a pure way, and this purity gives fertile ground for nice abstractions for concurrency. But every application needs to talk to the outer world, hence the need to understand the other, impure, side of the coin.

This workshop is not only useful for those working in Haskell codebases. The same ideas and concepts pop up when using other languages in a pure functional manner, such as Scala with Cats/Scalaz, Kotlin with Arrow, or Swift with Bow.

Contents

The workshop is divided into three parts:

• The Yin: Pure modeling
• Simple modeling using algebraic data types
• Extracting dependencies into type classes
• Modeling services using monads
• Enforcing more invariants using GADTs
• The Yang: Impure execution
• The base model: Laziness and exceptions
• Basic input/output in the IO monad
• Cheap concurrency using green threads and STM
• Streams of data: Databases and message queues
• The Duality: Common architectural patterns
• Functional core, imperative shell
• Onion architecture

Tickets and more information here

Making the Most of Scala Through Functional Programming by Habla Computing

You may have already experienced that Scala allows you to write programs as if you were still using Java. While this has unquestionable benefits in terms of lowering entry barriers to newcomers, it may also cause you to forget that the significant source of power for Scala lies elsewhere, namely, in its support for functional programming.

This workshop will introduce three major functional abstractions that will bring you to the next level of programming maturity: Higher-order functions, type classes, and monadic functions; and, more importantly, it will show you why they matter so much, i.e., how they help you to achieve unprecedented levels of reuse and modularity, while keeping your programs concise and understandable.

You Don't Own Me

For people coming from functional languages, you may wonder when you would want to use Rust. Rust has functional patterns and takes ideas from substructural type systems. A combination of functional patterns, the borrow checker, and drop checker enable us to have nice program control flow you'd expect with a functional language and granular control of our system resources. In this talk, we'll explore how Rust empowers programmers to write logically correct and memory safe programs.

Arrow Meta - Enabling Functional Programming in the Kotlin Compiler

Arrow Meta is a library that empowers library and application authors with the ability to write plugins for the Kotlin compiler. Compiler plugins have access to all compiler phases and can intercept and modify the AST, descriptors, and IR intermediate lang for bytecode generation. In this talk, Simon Vergauwen and Raul Raja, Arrow maintainers from 47 Degrees, will go over the main features of Arrow Meta and how the Arrow library aims for:

• Bringing first-class FP capabilities to the Kotlin compiler.
• Provide a framework for developers to write compiler plugins easily.

If you attend this talk, you will learn how the Kotlin compiler works internally and how you can write compiler plugins with the Arrow Meta library.

We will discuss some of the current Arrow plugins in development and the future and state of FP in Kotlin:

• Keep 87. Type class and extension families
• Monad Comprehensions
• Higher Kinded Types
• Automatic Optics derivation
• Refined types

Building FP-Centric Microservices

This workshop will introduce Mu, a library for building purely functional RPC microservices.

We’ll cover how to define protocols using IDL, build a microservice based on this protocol, and then create a client to communicate with the service using cats-effects behind the scenes.

This workshop will show the actual implementation of Functional Programming throughout an entire project and cover related topics like side-effects management.

The goal of this workshop is to teach attendees how to develop a microservice using Mu and cats-effects.

For this workshop, it is necessary to have installed SBT and Java 8. Furthermore, it's recommended to have basic knowledge of Scala and cats-effects.

Painless software development with Haskell

Developers interested in seeing Haskell being used as a general programming language. Engineers hoping to see Haskell as an environment in which one can quickly and effectively iterate between requirements, design and running, executable code - providing value to the business with an immediate feedback loop. Developers eager to see how they can rapidly create software that is flexible to changes, extensible and testable.

Pre-requirements:

• basic understanding of Haskell syntax (functions, composition, do-notation, type classes)
• basic FP building blocks: functor, monad
• (optionally) some previous exposure to free monads
• (optionally) scars and war stories of using tagless final in Haskell

• Tech stack we will explore:
• polysemy
• servant