Live Coding Eff in Anger

Modularity and extensibility are keys when writing software systems. There exist few options when one wants to write modular, extensible, effectful code in Haskell: basically mtl-style typeclasses and free monad derivatives. Extensible effects, aka the Eff monad, is a solution loosely based on the free monad technique using the freer package for fun and profit.

This session is a live-coding, pair-programming introduction to the use of `Eff` to structure an application decoupled in distinct components with strict interfaces. We will interactively develop a simple yet realistic Eff-based Pet Store REST service, demonstrating how to code and test the various effects introduced, how to compose them to produce the desired service, how to leverage the existing standard effects provided by the freer package, and the various ways of writing interpreters and how to handle the sometimes daunting type-checker errors.

 
 

Outline/Structure of the Demonstration

45 minutes of live pair coding showing how fun it can be to work together on Haskell code. We are migrating over a Pet Store demo application to use the freer-simple Eff library and show how to do it.

Learning Outcome

You'll know how to practically use extensible effects aka the Eff monad. With some particular demonstration of the freer-simple library.

Target Audience

functional programmers interested in practical topics on code modularity

schedule Submitted 1 year ago

Public Feedback

comment Suggest improvements to the Speaker

  • Liked Michael Snoyman
    keyboard_arrow_down

    Michael Snoyman - Functional Programming for the Long Haul

    Michael Snoyman
    Michael Snoyman
    VP, Engineering
    FP Complete
    schedule 1 year ago
    Sold Out!
    45 Mins
    Keynote
    Beginner

    How do you decide whether a programming language is worth using or not? By necessity, such decisions are usually based on assessments that can be made relatively quickly: the ease of using the language, how productive you feel in the first week, and so on. Unfortunately, this tells us very little about the costs involved in continuing to maintain a project past that initial phase. And in reality, the vast majority of time spent on most projects is spent in those later phases.

    I'm going to claim, based on my own experience and analysis of language features, that functional programming in general, and Haskell in particular, are well suited for improving this long tail of projects. We need languages and programming techniques that allow broad codebase refactorings, significant requirements changes, improving performance in hotspots of the code, and reduced debug time. I believe Haskell checks these boxes.

  • Liked Anupam Jain
    keyboard_arrow_down

    Anupam Jain - Purely Functional User Interfaces that Scale

    45 Mins
    Talk
    Beginner

    A virtual cottage industry has sprung up around Purely functional UI development, with many available libraries that are essentially just variants on two distinct approaches: Functional Reactive Programming (FRP), and some form of functional views like "The Elm Architecture". After having worked extensively with each of them, I have found that none of the approaches scale with program complexity. Either they are too difficult for beginners trying to build a hello world app, or they have unpredictable complexity curves with some simple refactorings becoming unmanageably complex, or they "tackle" the scaling problem by restricting developers to a safe subset of FP which becomes painful for experienced developers who start hitting the complexity ceiling.

    In this talk I give an overview of the current Purely Functional UI Development Landscape, and then present "Concur", a rather unusual UI framework, that I built to address the shortcomings of the existing approaches. In particular, it completely separates monoidal composition in "space" (i.e. on the UI screen), from composition in "time" (i.e. state transitions), which leads to several benefits. It's also a general purpose approach, with Haskell and Purescript implementations available currently, and can be used to build user interfaces for the web or for native platforms.

    The biggest advantage of Concur that has emerged is its consistent UI development experience that scales linearly with program complexity. Simple things are easy, complex things are just as complex as the problem itself, no more. Reusing existing widgets, and refactoring existing code is easy and predictable. This means that Concur is suitable for all levels of experience.

    1. For Learners - Concur provides a consistent set of tools which can be combined in predictable ways to accomplish any level of functionality. Due to its extremely gentle learning curve, Concur is well suited for learners of functional programming (replacing console applications for learners).
    2. For experienced folks - Assuming you are already familiar with functional programming, Concur will provide a satisfying development experience. Concur does not artificially constrain you in any form. You are encouraged to use your FP bag of tricks in predictable ways, and you are never going against the grain. It's a library in spirit, rather than a framework.
  • Liked Luka Jacobowitz
    keyboard_arrow_down

    Luka Jacobowitz - Testing in the world of Functional Programming

    45 Mins
    Demonstration
    Intermediate

    Testing is one of the most fundamental aspects of being a software developer. There are several movements and communities based on different methodologies with regards to testing such as TDD, BDD or design by contract. However, in the FP community testing is often not a large topic and is often glossed over. While it’s true that testing in functional programming tends to be less important, there should still be more resources on how to create tests that add actual value.

    This talks aims to provide exactly that, with good examples on how to leverage property based testing, refinement types and the most difficult part: figuring out how to test code that interacts with the outside world.

  • Liked Mark Hibberd
    keyboard_arrow_down

    Mark Hibberd - Property Based Testing

    Mark Hibberd
    Mark Hibberd
    Head of Technology
    Kinesis
    schedule 1 year ago
    Sold Out!
    90 Mins
    Workshop
    Beginner

    Building on the earlier two introductions to functional programming with types, property based testing is the extra verification technique you need to ensure working software. We will work through the patterns of property based testing, starting with simple functions, working up to verification of a larger program.

    By the end of this workshop participants will have a better understanding of the advantages of property based tests over example based tests, as well as acquiring the skills and confidence to start applying property based testing techniques to their current work.

    This workshop has the same requirements as Tony's introduction, and will require a recent clone of the workshop repository available at https://github.com/markhibberd/property-based-testing-workshop.

  • Liked Sean Chalmers
    keyboard_arrow_down

    Sean Chalmers - Condensed Applied FP Course

    480 Mins
    Workshop
    Intermediate

    Intermediate functional programmers often find it daunting to move from examples provided in books and blogs to developing their first fully functioning application. The Queensland Functional Programming Lab at Data61/CSIRO have produced a course for exactly this purpose. Building on the fundamentals, we work through the process of constructing a REST application covering the following topics:

    • Package dependencies
    • Project configuration
    • Application testing & building
    • Encoding / decoding messages
    • Persistent storage integration
    • App state & configuration management
    • Error handling & reporting

  • Liked Gabriel Volpe
    keyboard_arrow_down

    Gabriel Volpe - Cats Effect: The IO Monad for Scala

    Gabriel Volpe
    Gabriel Volpe
    Software Engineer
    Paidy Inc
    schedule 1 year ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Since the first introduction of [Cats Effect](https://typelevel.org/cats-effect/) many things have changed taking its design and performance to a whole new level.

    Come join me and learn how to deal with side effects in a pure functional way while abstracting over the effect type and taking composition to the next level. We will review the most important features such as synchronous and asynchronous computations, error handling, safe resource management, concurrency, parallelism and cancellation starting by reviewing the basic concepts.

  • Liked Aloïs Cochard
    keyboard_arrow_down

    Aloïs Cochard - The Magnum Opus

    45 Mins
    Talk
    Beginner

    From Ancient Egypt to the Middle Ages humanity lost it's way in the quest to find the philosopher's stone.

    While following the recent advance in machine learning one might think that we are running in that same quest again,
    only differences this time are that our philosopher's stone is deep learning and the promise is general artificial intelligence instead of immortality.

    The current machine learning ecosystem is mainly based on python and pretty much feels like alchemy,
    lot of trial and errors, lack of tooling and good engineering practices, ...

    Let's take a tour of the current ecosystem and see how can we do better and safer high performance machine learning using Haskell!

  • Liked Gabriel Volpe
    keyboard_arrow_down

    Gabriel Volpe - Beautiful Folds

    Gabriel Volpe
    Gabriel Volpe
    Software Engineer
    Paidy Inc
    schedule 1 year ago
    Sold Out!
    45 Mins
    Demonstration
    Intermediate

    A journey from statistics computations to composable streaming folds.

    Come join me and learn by example about the beauty of generic folds and streaming data. I'll be revisiting these concepts, talking about its origins in Haskell and demonstrating the power of them by showing an example of a program that runs statistics computations using the Fs2 and Origami Scala libraries.

    Inevitably, I'll also be talking about performance, concurrency, parallelism and some type classes such as Foldable, Applicative and Monoid, you won't be bored!