f(by) 2017 20162015

f(by) — Conference on Functional Programming

This year we are focusing on a number of FP languages: Haskell, Elm, Clojure, PureScript, ClojureScript. Thanks to your requests we're bringing a dedicated Scala-track back to F(by).
We were super lucky to get approves from several contributors and influencers in FP world.

The event will deliver 2 types of content:

1. hands-on sessions (including workshops) where you can try the technology;
2. presentations on guts of FP languages.

In addition, you will learn more about using FP in web, VR and devops, how it might help you to simplify the code maintenance process. Traditionally we will go ahead with math in programming and learn more about category theory.



  • 9.30 – 10.00


  • 10.00 – 10.45

    What Makes Haskell Unique

    Michael Snoyman

    Haskell has purity, immutability, referential transparency, and so on. But how does that affect the programs we write? We'll discuss some subtle and not-so-subtle outcomes—both positive and negative—that come from the architectural choices at the root of Haskell.

  • 10.50 – 11.35

    Elm Make it Amazing with Types

    Zachary Kessin

    I will introduce the Elm language and show how the type system makes doing development in Elm easy and pleasant. No prior experience with Elm is required.

  • 11.35 – 11.50


  • 11.50 – 12.35

    A Crash Course in Category Theory

    Bartosz Milewski

    Programming is math and math is programming. But the kind of math that's useful in programming is not what they teach you in school. In fact it's much more interesting. Category theory seems to be esoteric when presented by mathematicians, because all their examples come from other branches of mathematics. But when you use examples from programming, things suddenly becomes quite obvious. And the reason there is such a close fit between category theory and programming is quite simple: both are built on the principle of composability.

  • 12.40 – 13.25

    The Way to Simplicity: How Haskell Simplifies Code Maintenance

    Denis Shevchenko

    Code maintenance is a painful process, and it will be painful forever. We cannot take this pain away, but we can relieve it. In this talk I'll show you how the Haskell can help us and make our lives more happier.

  • 13.25 – 14.30


  • 14.30 – 15.15

    Functional Virtual Reality: WebVR in Haskell

    Nikolay Kudasov

    Virtual Reality is more accessible than it might seem. With Google Cardboard and WebVR anyone can create VR experiences. And now with GHCJS we can explore VR with Haskell easily and type-safe! In this talk we'll see how to get started with VR in Haskell and how to interoperate with existing libraries out there. Specifically we're going to explore A-Frame, a JavaScript framework for WebVR, and miso, a Haskell frontend framework, inspired by Elm.

  • 15.20 – 16.05

    Strongly-Typed Web Apps in Haskell

    Alejandro Serrano Mena

    Web development is one of the main activities in programming. In this talk we look at different components of a web application from the point of view of Haskell. In particular, I shall introduce Servant's approach to type-safe routing, Aeson to work with JSON data types with zero boilerplate, and Persistent for database access. Each of these parts also introduces an advanced Haskell feature: type-level computation, generic deriving and Template Haskell.

  • 16.05 – 16.20


  • 16.20 – 17.05

    Impromptu: Representing Async Graphs with Dependent Types

    Jon Pretty

    Writing asynchronous code is often an uneasy fit for a language like Scala. While high-level constructs like Futures facilitate asynchronous programming, syntactic limitations often make blocking or the unchecked access of asynchronously-computed values more natural than the safer alternatives.

    In this talk, you will discover Impromptu, a lightweight Scala API for safely defining and executing graphs of dependent tasks, avoiding blocking and preventing access of not-yet-completed values, guaranteed the type system.

    You will use a combination of several advanced type-system features to encode a task's dependencies, then use these types as constraints to restrict access within a task only to the results of dependent tasks which are known to have been completed. You will further take advantage of Scala's type inference to avoid polluting the code with cumbersome type ascriptions. This gives you very lightweight and natural syntax, without blocking or unsafe access.

    During this talk, you will explore how Impromptu is implemented, and learn how dependent types allow the framework to be written in just 30 lines of code, and show how a similar approach may be used to concisely implement typed actors.

    Furthermore, you will take advantage of current research into implicit functions in Dotty to remove the small amount of remaining boilerplate from Impromptu task definitions.

  • 17.10 – 17.55

    Fast and Fearless Evolution of Server-Side Web Applications

    Oskar Wickström

    When evolving web applications, in most programming languages and frameworks, we risk introducing programming errors. Undefined values, parsing failures, broken links, invalid markup, and good old null pointers, are all things that can break our applications. Manually writing and maintaining tests to catch programming errors is a time consuming effort, and we would rather spend that time testing our application logic. This talk takes you on a whirlwind tour of mature technologies that offer static guarantees for modern web applications.

  • 9.30 – 10.00


  • 10.50 – 11.35

    Exploit You a Fiddle for Great Docs!

    Otto Chrons

    ScalaFiddle is best known as an online playground for writing and sharing short Scala code snippets, fiddles. But it also acts in embeddable form, making it a great tool for enhancing your library documentation. In this talk we go through how to convert your documentation's static code examples into interactive fiddles and what are the different ways of achieving that. We also cover the architectual and design choices in ScalaFiddle that make it "web scale".

  • 11.35 – 11.50


  • 11.50 – 12.35

    Scala Development in IntelliJ Idea: from A to Z

    Mikhail Mutcianko

    IntelliJ IDEA being one of the most popular development tools for Scala, packs plenty of features which help you stop wasting time and energy on routine tasks.
    Some of them are common knowledge, some are hidden gems that make full use of the underlying intelligent platform.
    In this talk I will make an attempt both to introduce the newcomers to IntelliJ platform and uncover some of the power features that even experienced users might not have known.

  • 12.40 – 13.25

    Full Stack in «One» Language, or Rich Hickey's Isomorphism.

    Nikolay Ryzhikov

    A talk on how to develop using the whole stack from infrastructure to mobile and css coding in one language - Clojure.

  • 13.25 – 14.30


  • 14.30 – 15.15

    Magic at Compile Time. Metaprogramming in Scala.

    Bartosz Babol

    Let's have some fun with metaprogramming in Scala. Is there better place for that than Minsk in Belarus? I will do my best to convince you that you should spend few last evenings of 2017 writing some (compile time) magic. If you don't use Scala I hope you will find inspiration to dig deeper into metaprogramming in your language of choice.

  • 15.20 – 16.05

    Type-level State Machines for Detailed Effect Checking

    Roland Kuhn

    The effects performed for example by an Actor can be tracked using indexed monads and compared with a specification that can be derived from a session type. In this fashion we can ensure that the right type of message is communication at the right time, child actors are created when appropriate, and more; it is crucial to note that for this we need not only to register which kinds of effects are performed but also their individual type parameters and sequence. However, the resulting effect types quickly become complex and tedious to read, especially in Scala type errors. This presentation highlights an approach that validates effects while constructing the computation, using implicit evidence to transition between the different states of the specified communication protocol.



Participant Partners

  •  3191
  •  2915
  •  3192
  •  676
  •  3211


  • dev.by 3
  •  2132
  •  2124
  • jobstutby 1826