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.
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.
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!
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!
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.
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.
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.
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.
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.
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.
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
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/
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.
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!
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.
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.
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.
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 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.
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 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!
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!
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.