flatMap(Oslo) 2018
3-4 May 2018, Oslo Norway

Talks

Announced talks

A Little Taste of Dependent Types

Presentation
by
David Thrane Christiansen

Dependent types let the same language be used to write types and the programs they describe. They also let us write mathematical proofs using the tools we know from functional programming. Based on an upcoming book, “The Little Typer”, I’ll show the core ideas from dependently typed programming.

Details

Advanced Tagless Final - Saying farewell to Free

Presentation
by
Luka Jacobowitz

Tagless Final has been a hot topic the last couple of years. It’s a great concept, but we can make it even better! This talk aims to look at some more advanced techniques like making any inspecting and generically optimizing tagless final programs and discover different libraries on the way.

Details

Akka: A Best Friend (Forever!) for your Backend-for-Frontend

Presentation
by
David van Geest

Would you like to break up a monolith into microservices? Would you like to push live data to your end-users? This talk will teach you how to use the Backend-For-Frontend pattern to answer these questions. PagerDuty implemented BFFs with Akka HTTP and Streams, and we’re here to share our learnings!

Details

Are you writing Java in Clojure?

Presentation
by
Erik Assum

As I dove into yet another Clojure codebase, it was whispering very quietly. I couldn’t quite figure out what it was saying, but it caught my attention.

A couple of months later, I finally understood.

Although it was written in Clojure, it was just a java app in disguise!

Details

Church Encoding in Concatenative Programming Languages

Presentation
by
Teodor Ande Elstad

How would Church encoding look if you try to implement it in a concatenative language? Can it even be done? In this talk we’ll try to do just that, more or less live, and on the way we’ll learn about concatenative programming, and the deep relations between concatenative and functional programming.

Details

Declarative Control Flow with Fs2 Stream

Presentation
by
Fabio Labella

fs2 support for concurrency means that we can use streams to model program flow in a composable, declarative fashion. This talk will introduce the main concurrency abstractions of fs2 through practical examples.

Details

Domain Modelling with Haskell Data Structures

Workshop
by
Oskar Wickström

Attendee preparation:
For the ones that want to follow along on their computer, they need to prepare by following the "Setup" section: https://owickstrom.github.io/domain-modelling-with-haskell-workshop/

Haskell is an amazing language for domain modelling, with its expressive data types and highly reusable abstractions. In this workshop we will design the core of a simple project management system, and explore different ways of traversing and folding our data when implementing new features.

Details

Droidspeak - A DSL for constructing binary decision trees in a friendly way

Presentation
by
Doug Clinton and Martin Carolan

Domain specific languages (DSLs) are an effective way to bridge the gap between business requirements and their implementation. In this talk we present a DSL, Droidspeak, that we created to conveniently express decision tree paths and compile them into provably complete decision trees.

Details

Fantastic Monads and where to find them

Presentation
by
Jakub Kozłowski

In this talk, I introduce the audience to functional patterns like Applicative/Monad in an easily approachable way, by showing real world use-cases for them.

Details

Free All The Things!

Presentation
by
Markus Hauck

Have you ever asked yourself why we only free monads? Turns out there are a lot of other structures that want to be liberated from the constraints of their existence! In this talk we will investigate what other poor (algebraic) structures we can free from the dirty hands of imperative programmers.

Details

From NAND to Lambda: Foundational Computing Through Functional Principles

Presentation
by
Ryan Moore

Functional and descriptive programming techniques are used broadly at the hardware level, and there’s more in common with Functors and Monoids and circuits than you might think. This engaging and entertaining talk that bridges the gap between functional software and foundational hardware principles

Details

Getting started with Fable - F# to JS compiler

Workshop
by
Krzysztof Cieślak

Attendee preparation:
To complete the workshop, you will need to install all the Fable pre-requisites and get an F# editor that works well with Fable. All requirements of Fable are described in its getting started guide - http://fable.io/docs/getting-started.html. It should include Mono which is described as optional requirement in the guide. While any F# IDE should work just fine, the recommended setup is to use Ionide in VS Code - http://ionide.io/

Javascript has conquered the world – you can use it in the browser, on the server, to write mobile apps, or on the desktop with Electron. During the workshop you will learn how to bring the power of F# - modern functional-first language – to huge and rich JS world using Fable – F# to JS compiler.

Details

Integrating IDEs with Dotty, the experimental Scala compiler

Presentation
by
Guillaume Martres

A great programming language should provide a great developer experience! This is why Dotty comes built-in with IDE support that is designed to be easy to use, robust and extensible. In this talk I’ll describe the technologies used to implement this as well as our future plans.

Details

Lambda Calculus Beep Boop

Presentation
by
Einar W. Høst and Jonas Winje

We present beep boop, a representation for lambda calculus terms inspired by sound. It is a humane alternative to de Bruijn notation. It is much easier to utter a sequence of symbols in beep boop than in traditional lambda-based representations. Pretty useful for humans!

Details

Learning cats-effect by Accident

Presentation
by
Paulo "JCranky" Siqueira

Contributing to OpenSource is great, and learning while doing so is even better. This is the story of how I learned cats-effect and other tools from its ecosystem, while contributing to an awesome OS project and community.

Details

Make your own meta-circular evaluator!

Workshop
by
Heidi Mork and Jonas Winje

Attendee preparation:
Bring a laptop with DrRacket (https://racket-lang.org/) installed.

Building evaluators is a fun way to learn about programming languages. “Amb” is cool because it’s a pretty small extension to a more regular FP lang, but it’s enough to make it feel like proper different to program in, and makes certain programs (particularly backtracky ones) really easy to write.

Details

Regaining Control with State Monad and Friends

Presentation
by
Felix Mulder

From side-effect free state modification to Finite State Machines. The State Monad is immensely useful and actually - not scary at all. In this talk we’ll get comfortable with the state monad from Cats, and learn how we can write functional APIs that describe state transition on the type level.

Details

Scala for Java developers

Workshop
by
Magnus Härlin

Attendee preparation:

  • Install SBT
  • If you want an IDE to work with follow the instructions on Scala site

Gentle introduction to Scala and without to much focus on the new scary concepts such as immutability, first-class functions, implicits, and a ton of language features.

Details

Scalaz 8: A Whole New Game

Presentation
by
John A. De Goes

Scalaz 8 is the latest edition of the popular functional programming library for Scala. In this whirlwind tour, maintainer John A. De Goes discusses some of the hottest features of Scalaz 8, including a fast, concurrent effect system, a non-linear type class hierarchy, & powerful polymorphic values.

Details

Six steps from zero to IDE

Presentation
by
Ólafur Páll Geirsson

Why is it so hard to build a good IDE for Scala? Compared to JavaScript or Clojure, one would think that static types in Scala make it easier to provide a great editor experience. With the introduction of the Language Server Protocol, things may be changing for the better.

Details

The (un?) reasonable effectiveness of mathematics in computer programming

Presentation
by
Gabriel Claramunt

What if we use math to solve programming problems? Let’s take a tour through lambda calculus, the Curry-Howard equivalence, and category theory, and explore the relationship of math and programming, the rich span of possibilities opened by it, and why that matters.

Details

Type Classes in Scala: from Zero to Hero

Presentation
by
Jacek Kunicki

Type classes are basically just another way to achieve polymorphism in your code. Scary as they may seem, it turns out the idea is pretty straightforward, yet very powerful. And there’s a good chance you have already used them. Let me convince you during this live-coding session!

Details

What Haskell taught us when we weren't looking

Presentation
by
Eric Torreborre

Haskell, the far away language that (almost) no one uses? Not quite, this talk shows that Haskell deeply influences your favorite language, subverting OO, forcing syntax and type systems to evolve. Caution: after this talk you might want to use the real thing!

Details

Winter is coming

Presentation
by
Luís Ferreira

Design Drive Development, CQRS, Event Sourcing and Elixir all in one talk. Sounds fun? In this talk we’ll go over all of these and how they can work in tandem to give your apps the separation of concerns and scalability they need.

Details