f(by) 2017 20162015
#FuncBY

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.

Speakers

Program

  • 9.30 – 10.00

    Registration

  • 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

    Coffee

  • 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

    Lunch

  • 14.30 – 15.15
  • 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

    Coffee

  • 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 Wisktrom

    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 technologies that give static guarantees for web applications, such as type-safe markup DSLs, applicative form parsing and construction, and lifting the entire web application structure to the type-level to ensure correctness and derive program behavior.

Organizers

Partners

Participant Partners

MEDIA PARTNERS

  • dev.by