Talks
Announced talks
A Little Taste of Dependent Types
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.
Advanced Tagless Final - Saying farewell to Free
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.
Akka: A Best Friend (Forever!) for your Backend-for-Frontend
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!
Are you writing Java in Clojure?
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!
Church Encoding in Concatenative Programming Languages
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.
Declarative Control Flow with Fs2 Stream
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.
Domain Modelling with Haskell Data Structures
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.
Droidspeak - A DSL for constructing binary decision trees in a friendly way
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.
Fantastic Monads and where to find them
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.
Free All The Things!
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.
From NAND to Lambda: Foundational Computing Through Functional Principles
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
Getting started with Fable - F# to JS compiler
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.
Integrating IDEs with Dotty, the experimental Scala compiler
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.
Lambda Calculus Beep Boop
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!
Learning cats-effect by Accident
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.
Make your own meta-circular evaluator!
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.
Regaining Control with State Monad and Friends
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.
Scala for Java developers
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.
Scalaz 8: A Whole New Game
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.
Six steps from zero to IDE
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.
The (un?) reasonable effectiveness of mathematics in computer programming
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.
Type Classes in Scala: from Zero to Hero
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!
What Haskell taught us when we weren't looking
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!
Winter is coming
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.