Pre-Conf Workshop

Wed, Dec 12
09:30

    Registration - 30 mins

10:00
  • Added to My Schedule
    keyboard_arrow_down
    Michael Snoyman

    Michael Snoyman - Applied Haskell Workshop

    schedule 10:00 AM - 06:00 PM place Board Room 1 people 21 Interested

    This full day workshop will focus on applying Haskell to normal, everyday programming. We'll be focusing on getting comfortable with common tasks, libraries, and paradigms, including:

    • Understanding strictness, laziness, and evaluation
    • Data structures
    • Structuring applications
    • Concurrency and mutability
    • Library recommendations

    By the end of the workshop, you should feel confident in working on production Haskell codebases. While we obviously cannot cover all topics in Haskell in one day, the goal is to empower attendees with sufficient knowledge to continue developing their Haskell skillset through writing real applications.

    Attendees will be provided with a recommended prereading list to get the most out of the workshop.

  • Added to My Schedule
    keyboard_arrow_down
    Anne Ogborn

    Anne Ogborn - Introduction to Logic Programming and SWI-Prolog

    schedule 10:00 AM - 06:00 PM place Board Room 2 people 10 Interested

    As machine learning matures, it is becoming obvious that we need explainable solutions. As functional programmingmatures it becomes obvious that we need inference and nondeterminism. And linked open data demands reasoning. This all day workshop will introduce the logic programming paradigm, in which programs are expressed as a set oflogical rules and executed by finding proofs of queries.

    SWI-Prolog is the most highly developed and widely used language for logic programming.

    The language, which has been in continuous use in academic research settings since it's invention in 1972, provides unparalleled power. Many problems which would be difficult to express in other languages are simple in SWI-Prolog.SWI-Prolog is a 'batteries included' modern language, ready for real world tasks like web development and process control.

    In this dynamic hands on workshop we'll learn the basics of SWI-Prolog, and look at some of the amazing things it can do.

Bootcamp Day

Thu, Dec 13
09:30

    Registration - 30 mins

10:00
  • Added to My Schedule
    keyboard_arrow_down
    Tony Morris

    Tony Morris - Introduction to Haskell syntax and tools

    schedule 10:00 AM - 11:30 AM place Senate 1 people 10 Interested

    In this workshop, an attendee can expect to go from zero knowledge about Functional Programming in Haskell to familiarity with almost all of the syntax of the Haskell programming language, and associated tools. The general workflow of working with Haskell will be demonstrated in preparation for the subsequent workshops for the remainder of the day.

    We will define Functional Programming to set the structure for the remainder of the day. We will explore most of the Haskell syntactic constructs and create your own reference material.

    Participants will require a laptop with [GHC](http://haskell.org/ghc) and their favourite text editor installed.

    We will explore the tooling that is provided with GHC to provide a basic workflow, so that the participant can later independently work with and explore other ideas with Haskell.

  • Added to My Schedule
    keyboard_arrow_down
    Tamizhvendan S

    Tamizhvendan S - Demystifying Functional Programming

    schedule 10:00 AM - 11:30 AM place Senate 2 people 3 Interested

    Because of some perceived complexities and the mathematical background in functional programming, the beginners get bogged down while learning and putting it into practice. As a matter of fact, few people give up after some initial attempts. But it is not as much harder as we think. It is just different!

    Together, let's experience a different perspective of functional programming and get started in a better way

  • Added to My Schedule
    keyboard_arrow_down
    Stavros Aronis

    Stavros Aronis - Welcome to the Erlang Ecosystem

    schedule 10:00 AM - 01:00 PM place Board Room people 1 Interested

    "Are there really companies that use Erlang?" is the most common (and by now expected) question I have been asked by my peers ever since I joined the Erlang Solutions office in Stockholm, not too long ago. "Why?" is, naturally, the second question. In this introductory workshop I will explain what are the key ideas that Erlang is built upon, how these ideas have evolved into a powerful set of design patterns that compose the Erlang/OTP framework and why these ideas and patterns are useful to plenty of industries that use Erlang (and not merely to telecom!). I will also introduce the language ecosystem that has evolved around Erlang, including languages such as Elixir, LFE, and Alpaca.

11:30
  • Added to My Schedule
    keyboard_arrow_down
    Brian McKenna

    Brian McKenna - Starting Data61 Functional Programming Course

    schedule 11:30 AM - 01:00 PM place Senate 1 people 8 Interested

    Following Tony and Alois' Introduction to Haskell syntax and tools, we will work through the first few modules of Data61's Functional Programming Course. These modules cover writing functions for the optional and list data types.

    We will complete enough exercises to cover basic data types, functions and polymorphism. We'll practice the techniques of equational reasoning, parametricity and type/hole driven development. After completing these modules, you should be able to use the techniques to attempt most other exercises in the repository.

    This workshop has the same requirements as Tony's introduction, along with a download of a recent version of the fp-course repository (https://github.com/data61/fp-course).

  • Added to My Schedule
    keyboard_arrow_down
    Debasish Ghosh

    Debasish Ghosh - Power of Functions in a Typed World on the JVM

    schedule 11:30 AM - 01:00 PM place Senate 2 people 4 Interested

    John Carmac once mentioned on twitter that "Sometimes, the elegant implementation is just a function. Not a method. Not a class. Not a framework. Just a function." In this talk we will discuss the power of functions in modeling real world applications on the JVM. When we say functions, we mean "pure" functions as in the world of mathematics.

    Functions model behaviors, functions compose to build larger functions, and combined with a powerful type system allow us to abstract over the generalities in defining real world domain models. The combination of functions along with algebraic data types has proven to be extremely useful in designing large scale systems that are modular and extensible.

    Scala is a typed functional (well, almost) language on the JVM. In this session we will discuss how the functional features of Scala offer many of the above benefits in designing large scale systems. If you are coming from an OO background, you will appreciate how an alternative approach to programming can make your systems simpler to design, implement and maintain.

01:00

    Lunch Break - 60 mins

02:00
  • Added to My Schedule
    keyboard_arrow_down

    Data61 Functional Programming Course...continued

    schedule 02:00 PM - 03:30 PM place Senate 1 people 8 Interested
  • Added to My Schedule
    keyboard_arrow_down
    Aditya Athalye

    Aditya Athalye - Clojure By Example: What could one do with just a bit of Clojure?

    schedule 02:00 PM - 03:30 PM place Senate 2 people 3 Interested

    The goal is to introduce how a Clojure programmer would (typically) model things with pure data, design APIs, compose purely functional logic, and use the REPL to interactively "grow" and introspect code.

    This demo-style workshop is for practising programmers and CS undergrads/grads (not absolute beginners).

  • Added to My Schedule
    keyboard_arrow_down
    Sandesh Soni

    Sandesh Soni - Building Real-World app using Elm and Elixir Phoenix

    schedule 02:00 PM - 02:45 PM place Board Room people 1 Interested
    • Build an app more advanced than TODO app.
    • using ELM 0.19 and Elixir Phoenix for APIs.
    • Will be slides with code.
      i.e step by step what code/functions/methods need to write.
      Incremental sequence.
    • Login, Register user, upload file (will try to cover maximum)

02:45
  • Added to My Schedule
    keyboard_arrow_down
    Kiran Gangadharan

    Kiran Gangadharan / Udit Kumar - The Road to a Masterless Multi-node Distributed System in Elixir

    schedule 02:45 PM - 03:30 PM place Board Room people 2 Interested

    In this talk, we will cover our journey from the base to the summit of a masterless multi-node distributed system in Elixir. We’ll talk about the challenges faced, decisions made and how they shaped/evolved the architecture.

03:30

    Coffee/Tea Break - 30 mins

04:00
  • Added to My Schedule
    keyboard_arrow_down
    Mark Hibberd

    Mark Hibberd - Property Based Testing

    schedule 04:00 PM - 05:30 PM place Senate 1 people 8 Interested

    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.

  • Added to My Schedule
    keyboard_arrow_down
    Brian McKenna

    Brian McKenna - Eta and Nix for shipping Haskell to Java environments

    schedule 04:00 PM - 04:20 PM place Senate 2 people 4 Interested

    Eta compiles Haskell code to Java/JVM bytecode. It supplies a Foreign Function Interface for interoperating with Java code. Many existing Haskell libraries (e.g. lens, Servant, QuickCheck) are ported to Eta so it's possible to use them for many traditionally Java environments, including Amazon Lambda functions, Kinesis consumers and Spark jobs.

    The Nix expression language allows writing functions to specify builds. The Nix build tool takes these expressions and instantiates them into static build instructions. These instructions can then be realised and turned into outputs. At each step Nix' tooling provides a layer of purity.

    Using Eta and Nix together, we can use Haskell functions for applications and Nix functions for builds, then deploy them to Java environments!

  • Added to My Schedule
    keyboard_arrow_down

    Testing for Concurrency Errors using Concuerror by Stavros Aronis

    schedule 04:00 PM - 04:20 PM place Board Room people 1 Interested
04:25
  • Added to My Schedule
    keyboard_arrow_down
    Dhaval Dalal

    Dhaval Dalal - Destructuring and Pattern Matching

    schedule 04:25 PM - 05:10 PM place Senate 2 people 3 Interested

    In this session, we will look De-structuring and Pattern Matching in Functional Programming. What exactly each is and how differently it gets implemented in various languages like languages like Scala, Clojure, Haskell, Erlang, JavaScript. In some languages like Haskell and Scala, it takes a unified form, whereas in languages like Clojure, the two are different

    In OO paradigm, this is takes the form of Double-Dispatch or n-Dispatch and usually gets implemented as the famous (or infamous) Visitor Pattern. We will look at how this pattern is made defunct in FP paradigm using Pattern Matching.

  • Added to My Schedule
    keyboard_arrow_down
    Nitin Misra

    Nitin Misra - Background Processing in Elixir with GenStage

    schedule 04:25 PM - 05:10 PM place Board Room people 1 Interested

    We recently started working on a new Elixir project and had the need for a background processing system.

    We decided to build our own background processing system in Elixir.

    This talk describes why and how we built our own background processing system in Elixir.

    How we use Elixir's GenStage package for adding back-pressure between the producer and consumer stages and how we add support for custom rate-limiting between several pipelines.

05:15
  • Added to My Schedule
    keyboard_arrow_down
    Ravindra Jaju

    Ravindra Jaju - Asynchronous Functional Programming on the JVM

    schedule 05:15 PM - 06:00 PM place Senate 2 people 3 Interested

    We'll take a close look at core.async - the CSP library for Clojure(script).

    • The motivation
    • Problems suitable for CSPs to handle
    • Syntax
    • Patterns

    Given the minimalist nature of Lisps, the syntax is underwhelming, but applications can be exciting in the manner they make complex problems within reach.

  • Added to My Schedule
    keyboard_arrow_down
    Ravi Chandra Padmala

    Ravi Chandra Padmala - The little things (or) How do I OTP?

    schedule 05:15 PM - 06:00 PM place Board Room people 1 Interested

    A standard Elixir distribution comes with fault tolerance and concurrency
    primitives that are not available off the shelf in other ecosystems. These
    primitives have a learning overhead that is addressed by the excellent
    documentation that is available both for Elixir and Erlang/OTP.

    But, there isn't much literature describing idiomatic ways to use these
    primitives. Most publicly accessible discussions prescribe idioms and style for the
    language, but ignore the concurrency primitives that come with it. Perhaps
    because the most popular way to use Elixir does not require that you use these
    primitives directly.

    In this talk, I will unpack and discuss ways to idiomatically use three of
    Elixir's OTP behaviours:

    GenServer
    Supervisor
    Registry

05:30
  • Added to My Schedule
    keyboard_arrow_down

    Haskell Bootcamp Wrap up

    schedule 05:30 PM - 06:00 PM place Senate 1 people 8 Interested

Everyday FP

Fri, Dec 14
09:00

    Registration - 15 mins

09:15

    Program Overview and Important Announcements - 15 mins

09:30
  • Added to My Schedule
    keyboard_arrow_down
    Michael Snoyman

    Michael Snoyman - Functional Programming for the Long Haul

    schedule 09:30 AM - 10:15 AM place Crystal Ball Room people 13 Interested

    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.

10:30

    Coffee/Tea Break - 15 mins

10:45
  • Added to My Schedule
    keyboard_arrow_down
    Tony Morris

    Tony Morris - Parametricity, Functional Programming, Types

    schedule 10:45 AM - 11:30 AM place Crystal Ball Room 1 people 9 Interested

    In this talk, we define the principle of functional programming, then go into
    detail about what becomes possible by following this principle. In particular,
    parametricity (Wadler, 1989) and exploiting types in API design are an essential
    property of productive software teams, especially teams composed of volunteers
    as in open-source. This will be demonstrated.

    Some of our most important programming tools are neglected, often argued away
    under a false compromise. Why then, are functional programming and associated
    consequences such as parametricity so casually disregarded? Are they truly so
    unimportant? In this talk, these questions are answered thoroughly and without
    compromise.

    We will define the principle of functional programming, then go into
    detail about common problems to all of software development. We will build the
    case from ground up and finish with detailed practical demonstration of a
    solution to these problems. The audience should expect to walk away with a
    principled understanding and vocabulary of why functional programming and
    associated techniques have become necessary to software development.

  • Added to My Schedule
    keyboard_arrow_down
    Manoj Govindan

    Manoj Govindan - Going Forth to Erlang

    schedule 10:45 AM - 11:30 AM place Crystal Ball Room 2 people 1 Interested

    Forth is a classic imperative stack-based programming language that fills a very specific niche. Erlang is a concurrent, functional, fault-tolerant programming language that occupies another, albeit wider, niche. There is very little in common between the two except for a shared respect for Alan Turing. This session is a case study that narrates the story of building a bridge between the two languages. The bridge allows for Forth nodes to run in a Erlang controlled world, with the ability to talk to Erlang nodes, send messages, invoke processes and so on.

    In particular we'll discuss the various threading techniques used in Forth, listed below. We'll discuss how the choice of threading model impacts the design of the Erlang-Forth bridge.

    Indirect Threaded Code (ITC)

    A classical Forth threading technique. All the other threading schemes are considered "improvements" on this. Consider the following Forth expression:

      : SQUARE DUP * ;

    In a typical ITC Forth this would appear in memory as shown in the image below:

    Figure 1

    Direct Threaded Code (DTC)

    This model is different from ITC in one respect: the Code Field contains actual machine code, rather than the address of some machine code.

    Subroutine Threaded Code (STC)

    This model relies on the following fact: a high-level Forth definition is nothing but a list of subroutines to be executed.

    Token Threaded Code (TTC)

    This model optimizes for size, at the cost of speed. A token-threaded Forth keeps a table of addresses of all Forth words. The token value is then used to index into this table, to find the Forth word corresponding to a given token.

  • Added to My Schedule
    keyboard_arrow_down
    Mark Hibberd

    Mark Hibberd - Hanging on in Quiet Desperation: Time & Programming

    schedule 10:45 AM - 11:30 AM place Senate Hall people 2 Interested

    Time has a profound impact on the complexity of the systems we build.

    A significant amount of this software complexity comes from either an inability to recall previous states or the inability to understand how a state was arrived at.

    From the foundations of AI, LISP and functional programming [1], to causality in distributed systems [2], to the more grungy practices of immutable infrastructure, or the unreasonable effectiveness of fact-based approaches to large scale data systems; the ability to adequately cope with time, and the change and conflict it inevitably creates, is a common thread to being able to build and reason about these systems.

    This talk looks at the impact of time on system design. We will walk through examples of large-scale systems and their battles with complexity. At the end of the talk, the audience should start to see the common spectre of time and have an appreciation of how understanding time is fundamental to maintaining clarity, correctness and reliability in systems.

    [1] Situations, Actions, and Causal Laws
    John McCarthy
    http://www.dtic.mil/dtic/tr/fulltext/u2/785031.pdf

    [2] Times, Clocks and the Ordering of Events in a Distributed System
    Leslie Lamport
    https://amturing.acm.org/p558-lamport.pdf

11:45
  • Added to My Schedule
    keyboard_arrow_down
    Jayaram Sankaranarayanan

    Jayaram Sankaranarayanan - YAAeM : Yet Another Attempt To Explain M

    schedule 11:45 AM - 12:30 PM place Crystal Ball Room 1 people 1 Interested

    It's another attempt to explain Monads to all those who are curious of this M-word.

    The famous Mars Rover problem is used to demonstrate a solution for it using basic Haskell tools and then introduces Monads and demonstrates a solution using the State Monad.

  • Added to My Schedule
    keyboard_arrow_down
    Anupam Jain

    Anupam Jain - Purely Functional User Interfaces that Scale

    schedule 11:45 AM - 12:30 PM place Crystal Ball Room 2 people 2 Interested

    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.
  • Added to My Schedule
    keyboard_arrow_down
    Emily Pillmore

    Emily Pillmore - A Radically New Functional Blockchain Architecture: Chainweb

    schedule 11:45 AM - 12:30 PM place Senate Hall people 4 Interested

    Proof-of-work blockchain networks like Bitcoin, Litecoin and Ethereum are characterized by low throughput (5-15 transactions per second). Efforts to improve throughput through protocol modifications, such as block size increases, have no hope of reaching levels required to take on modern fiat-currency payment networks. However, efforts that seek to replace Proof-of-Work (Proof-of-Stake and variants) or integrate it with off-chain networks and processes (payment channels, side chains) degrade assurance, censorship resistance or trustless-ness of the original design. Recovering and elaborating on early proposals for Bitcoin scaling, we present ChainWeb, a parallel-chain architecture which can combine hundreds to thousands of Proof-of-Work blockchains pushing throughput to 10,000 transactions per second and beyond. The network transacts a single currency, using atomic and trustless SPV (Simple Payment Verification) cross-chain transfers orchestrated at the application layer with capability and coroutine support in the Pact smart contract language. Chains incorporate each other’s Merkle tree receipts to enforce a single “super branch” offering an effective hash power that is the sum of each individual chain’s hash rate. In addition to massive throughput, other benefits accrue from having a truly parallelized smart-contract blockchain system.

12:30

    Lunch Break - 45 mins

01:15
  • Added to My Schedule
    keyboard_arrow_down
    Michael Ho

    Michael Ho - Making the Switch: How We Transitioned from Java to Haskell

    schedule 01:15 PM - 02:00 PM place Crystal Ball Room 1 people 7 Interested

    In this case study presentation, SumAll's CTO, Todd Sundsted, and Senior Software Engineer, Michael Ho, will discuss the move from Java to Haskell along two parallel paths. First, the business/political story — how SumAll convinced the decision makers, fought the nay-sayers, and generally managed the people impacted by the transition. Second, the technical story — how they actually replaced their Java code with Haskell code. Along the way, they will address their hopes and expectations from transitioning from Java to Haskell, and will conclude with the results they've gained and seen to date.

  • Added to My Schedule
    keyboard_arrow_down
    Raghu Ugare

    Raghu Ugare / Vijay Anant - (Why) Should You know Category Theory ?

    schedule 01:15 PM - 02:00 PM place Crystal Ball Room 2 people 9 Interested

    Category Theory has been found to have a vast field of applications not limited to programming alone.

    In this fun-filled talk (Yes! We promise!) , we want to make the audience fall in love with Math & Category Theory in general, and Haskell in particular.

    We will address questions such as below:

    • What is the mysterious link between the abstract mathematical field of Category Theory and the concrete world of real-world Programming ? And why is it relevant especially in Functional Programming?
    • Most of all, how can You benefit knowing Category Theory ? (Examples in Haskell)

  • Added to My Schedule
    keyboard_arrow_down
    Saloni Vithalani

    Saloni Vithalani / Unmesh Joshi - Actor based architecture for world's largest optical telescope

    schedule 01:15 PM - 02:00 PM place Senate Hall people 3 Interested

    We will share how Thirty Meter Telescope is utilizing Akka-Typed based actor-messaging as a communication backbone to coordinate hundreds of hardware components.

    -------------------------------------------

    Thirty Meter Telescope (TMT) is going to be world's largest optical telescope once operational. It consists of multiple hardware component each supporting a custom communication protocol at firmware level. Telescope observation requires coordination across these components for tasks such as mirror rotation, instrument and filter selection etc. This talk will discuss how Akka-Typed based actor-messaging layer on top of these custom protocols enabled the task of building higher level operational software with relative ease.

    We will show that Akka-Typed allowed creating type-safe protocol layer and how akka actors helped with state management in presence async concurrent communication. In addition, we will discuss how support for lifecycle events, fault tolerance and supervision in actor model turned out to be a great fit for the task. This work is done as an open source project on github.

02:15
  • schedule 02:15 PM - 03:00 PM place Crystal Ball Room 1 people 8 Interested

    Laws, laws, laws. It seems as though whenever we learn about a new abstraction in functional programming, we hear about its associated laws. Laws come up when we learn about type classes like Functors, Monoids, Monads, and more! Usually laws are mentioned and swiftly brushed past as we move on to examples and applications of whatever structure we're learning about. But not today.

    In this talk, we'll learn about Functors and Monoids, paying close attention to their laws. Why should our abstractions have laws? We'll answer this question both by seeing powers we gain by having laws, and by seeing tragedies that can befall us without laws.

  • Added to My Schedule
    keyboard_arrow_down
    Dhaval Dalal

    Dhaval Dalal / Ravindra Jaju - Code Jugalbandi - Exploring Concurrency

    schedule 02:15 PM - 03:00 PM place Crystal Ball Room 2 people 3 Interested

    In Indian classical music, we have Jugalbandi, where two lead musicians or vocalist engage in a playful competition. There is jugalbandi between Flutist and a Percussionist (say using Tabla as the instrument). Compositions rendered by flutist will be heard by the percussionist and will replay the same notes, but now on Tabla and vice-versa is also possible.

    In a similar way, we will perform Code Jugalbandi (http://codejugalbandi.org) to see how the solution looks using different programming languages. This time the focus of Code Jugalbandi will be on exploring concurrency models in different languages. Functional Programming has made programming concurrency easier as compared to imperative programming. For deeper perspective on Code Jugalbandi, check out http://codejugalbandi.org/#essence-of-code-jugalbandi

  • Added to My Schedule
    keyboard_arrow_down
    Saurabh Nanda

    Saurabh Nanda - "Refresh-driven" development with Haskell & Elm

    schedule 02:15 PM - 03:00 PM place Senate Hall people 6 Interested

    We sorely missed the rapid "refresh-based" feedback loop available in Rails (and other dynamically typed web frameworks), while writing Haskell. Change your code, hit save, and refresh your browser!

    In this talk we will share a few tips on how we finally hit productivity nirvana with ghcid and automated code-gen.

    Best of both worlds -- rock-solid type-safety AND being able to reload code with every change.

03:00

    Coffee/Tea Break - 30 mins

03:30
  • Added to My Schedule
    keyboard_arrow_down
    Zubin Duggal

    Zubin Duggal - The Future of Haskell Tooling

    schedule 03:30 PM - 03:50 PM place Crystal Ball Room 1 people 6 Interested

    Haskell tooling, particularly editor and IDE integration has been sorely lacking for years. This talk will be a broad overview of the state of Haskell tooling, and the challenges faced by it. It will be derived from the experience of working on two summer of code projects trying to improve Haskell tooling.

    For tooling users, we will discuss different Haskell tools available today(intero, haskell-ide-engine, ghcid etc.), their differences and trade-offs with respect to build tool support(stack, cabal, new-build, nix, make etc.), editor integration, features, limitations and speed.

    We will go over the approach taken by haskell-ide-engine and the Language Server Protocol in order to solve these problems. Then we will discuss the new .hie file format designed to make information about Haskell source collected by GHC more accessible to tooling and users.

    Finally, for budding tooling writers, we will discuss the various approaches to writing programs that extract information from and manipulate Haskell source, and their pros and cons:

    • The GHC API
      • Via ghc-mod and haskell-ide-engine
    • ghc-exactprint
    • haskell-src-extras
    • GHC source plugins
    • .hie files
  • Added to My Schedule
    keyboard_arrow_down
    Harmeet Singh

    Harmeet Singh - Running Pure Functional Microservices On JVM

    schedule 03:30 PM - 03:50 PM place Crystal Ball Room 2 people 1 Interested

    Scala is one of the finest languages on JVM which help us in writing functional code. But can we further make our microservices more concurrent, less error-prone and generic/reusable?

    In this session, we would be answering the above questions by visiting one of the most powerful functional libraries in Scala i.e Scala-Cats, which provides abstractions for functional programming and make things developer friendly and feature rich. The syntax and classes of Scala-Cats are similar to Haskell. Various libraries are built over Scala-Cats which aids us in building a purely functional microservices over JVM. In this talk, we would be building microservices using typelevel projects like http4s, circe, doobie and more which are based on Scala-Cats.

    We would be demonstrating applications of various scala-cats libraries and perform basic CRUD operations using them. By using http4s we would be implementing synchronous, asynchronous and streaming rest endpoints, using doobie which is a pure functional JDBC layer for Scala etc.

  • Added to My Schedule
    keyboard_arrow_down
    Kunjan Dalal

    Kunjan Dalal - Scaling Elm / Fable Elmish Application

    schedule 03:30 PM - 03:50 PM place Senate Hall people 1 Interested

    Every time we heard the word Scaling, first thing comes to mind is Cloud and Distributed systems. In modern days client-side applications increased in complexity and size. This makes architecture very important to scale the client-side application; especially Single Page Application. In this talk, I will be explaining why one should be choosing (Fable) Elmish architecture and how to scale it for large to a very large application.

04:00
  • Added to My Schedule
    keyboard_arrow_down
    Tanmai Gopal

    Tanmai Gopal - Using Haskell to build a performant GraphQL to SQL compiler

    schedule 04:00 PM - 04:45 PM place Crystal Ball Room 1 people 7 Interested
    1. Motivation/Problem statement: Lifecycle of a GraphQL query
    2. Design Goals
    3. Why Haskell
    4. Compiler implementation details:
      1. Fast GraphQL parsing with parser combinators
      2. Modelling and manipulating the GraphQL AST with algebraic data types
      3. Software Transactional Memory: Concurrency constructs for scaling GraphQL subscriptions
    5. Summary with performance benchmarks
  • Added to My Schedule
    keyboard_arrow_down
    Luka Jacobowitz

    Luka Jacobowitz - Testing in the world of Functional Programming

    schedule 04:00 PM - 04:45 PM place Crystal Ball Room 2 people 7 Interested

    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.

  • schedule 04:00 PM - 04:45 PM place Senate Hall

    Domain Specific Languages (or Libraries because embedded DSLs are just that) are already quite popular.

    Modern languages have many useful language features that are conducive to create DSLs with more ease than ever before. Kotlin from JetBrains is a beautifully blended pragmatic programming language that packages many features from many programming languages. Kotlin also have infix operation which makes code written in a DSL made with Kotlin very easy to read (and therefore less error-prone).

    In this demonstration, I shall show couple DSLs made from Kotlin

    and will dissect the code LIVE to show audience how several language features in Kotlin (which sometimes requires playing with higher order functions) to develop these languages.

    *A Unit Testing DSL (a DSL to simplify unit testing of Kotlin, Java Code) that our grand/m/pa can use.

    -- All unit test frameworks serve the purpose but elegance is a different matter. A code that works, and a code that is elegant and works is art. In this example, audience will see how they can use several language features that Kotlin has to offer can be put together to create an elegant and expandable unit testing DSL.

    * A DSL for Web Scraping and Transformation.

    - - A special case of ETL, where Extraction happens from raw HTML, Transformation happens in memory using the DSL designed. and the Load happens by loading this data to a different schema/db/form/representation.

05:00

    BoF - 30 mins

05:30

    Closing Talk - 15 mins

Mastering FP

Sat, Dec 15
09:00

    Registration - 15 mins

09:15

    Program Overview and Important Announcements - 15 mins

09:30
  • Added to My Schedule
    keyboard_arrow_down
    Anne Ogborn

    Anne Ogborn - let over logic - What functional programming can learn from logic programming

    schedule 09:30 AM - 10:15 AM place Crystal Ball Room people 7 Interested

    48 years after it's invention, logic programming remains a less frequently used paradigm.

    What can functional programming learn from logic programming?

    Unification and nondeterminism are powerful constructs not strictly relegated to logic programming. We'll look at unification, nondeterministic completion, probabilistic computation, and constraint propagation in functional contexts.

10:30

    Coffee/Tea Break - 15 mins

10:45
  • Added to My Schedule
    keyboard_arrow_down
    Ravi Mohan

    Ravi Mohan - Experience Report: Building Shin - A Typed Functional Compiler For Computational Linear Algebra Problems.

    schedule 10:45 AM - 11:30 AM place Crystal Ball Room 1 people 6 Interested

    Abstract: I wrote a distributed (mostly) Functional Compiler in Scheme, OCaml and Elixir that incorporates knowledge of Computational Linear Algebra and domain specific knowledge to generate highly optimized linear algebra code from specification of problems. This talk is about lessons learned in the process.

    The problem:
    In every domain that uses computational linear algebra (which is all of engineering and science), we encounter the 'how to optimize a linear algebra expression into an optimized sequence of BLAS (or LAPACK or $linear_algera library) kernel calls' problem.

    Example: (if the math equations make you want to tear your hair out and go jump off a cliff, don't worry, it is just an example, you don't have to grok it. Just skim the equations The basic problem being addressed here is that solving such equations with code takes up a lot of effort and time from experts in computational linear algebra)


    Here is a linear algebra expression from a genetics problem , specifically GWAS -Genome Wide Association Studies, looking for significant associations for millions of genetic markers- where the essence of the problem [1] comes down to generating the most efficient algorithm possible that solves these equations

    This in turn involves solving a 2 dimensional sequence of Generalized Least Squared Problems of the form

    The algorithms to solve these can be directly coded up in Matlab or Julia. But there are problems with this approach, with this specific problem.


    1. For different input sizes, different algorithms give the most optimal performance. Which algorithm do you code up?


    2. Even for a given input size, there are multiple algorithms that compute the same result, but have differing computational characteristics depending on the hardware etc. How do you generate the optimal algorithm for your hardware ?


    3. Most importantly the structure of *this* specific problem allows optimizations that are specific to the problem which are not built into generic linear algebra routines. (Obviously, one can't expect MATLAB to incorporate problem specific information for every scientific/engineering problem ever). The GLS problems are connected to others, thus saving intermediate results can save hours of computation vs calculating every GLS problem from scratch

    In practice, one needs to be an expert in Computational Linear Algebra to come up with the optimized algorithm for a domain specific problem, and then write (say Fortran) code to use BLAS, LAPACK etc optimally to actualize this algorithm, often with much iteration, often consuming 100s of hours.

    The Solution:


    Incorporating this 'expert knowledge' into a compiler speeds up the time taken to arrive at the best solution (often by a factor of 100 or 1000), and allows Computational Linear Algebra experts to do more interesting things, like focus on their research.

    For this particular problem, the above equations, and additional knowledge of the problem domain are the input into an expression compiler. The output is highly efficient and 'proved correct' code

    In compiler terms, incorporating domain knowldege into the compilation process results in being able to apply optimizations to the generated Syntax Trees/Graphs, resulting in optimal algorithms. (note: the output of the compiler is a program in another language- say Matlab).

    In essence, "Domain Specific Compilers" consume knowledge about the structure of a problem and generate optimized code that solves that problem.

    Shin is one such compiler. It consumes a problem description and outputs highly efficient Julia code that solves the problem.

    This talk focuses on the engineering challenges I faced in building this compiler, with a special focus on the approaches that failed [5]

    Trivia:

    "Shin" is the Hebrew letter, not the English word meaning 'front of the leg between knee and ankle' ;-).

    Every company uses names from a common theme to name their servers and components - Athena, Zeus, Hercules , or Thor, Loki, Odin, or Jedi, Sith, Skywalker etc. We use Hebrew words, so we have Ruach, Melekh, Malkuth etc..

  • schedule 10:45 AM - 11:30 AM place Crystal Ball Room 2 people 6 Interested

    In this talk we'll discuss the design and implementation of a smart contract property verification tool for Pact.

    The revolutionary idea of putting computer programs in a blockchain to create smart contracts has opened up a whole new world of possibilities. But these programs have very different characteristics from other software. This talk explores these differences, some of the challenges that have been encountered, and then discusses how Kadena is solving these problems with its smart contract language Pact. We'll discuss the design and implementation of a smart contract property verification tool for Pact. We leverage these (lack of) features to build a system capable of proving many properties of contracts via the Z3 SMT solver. We'll also give examples of real bugs caught by the system.

11:45
  • Added to My Schedule
    keyboard_arrow_down
    Aaron W Hsu

    Aaron W Hsu - Does APL Need a Type System?

    schedule 11:45 AM - 12:30 PM place Crystal Ball Room 1 people 2 Interested

    APL is known for its concise problem-solving expressiveness, and it is used very successfully in places where high-quality and rapid iteration are requirements, not luxuries. Static Type Systems have had tremendous success throughout the computing industry, even receiving positive HCI usability studies that demonstrate their effectiveness on a number of metrics with mainstream and functionally-oriented programming languages. This success leads many programmers to take the value of type systems as a given, especially as mission-criticality and the age of a project increase. Therefore, it comes as a surprise to many, when learning about APL, that it has spent so long as an untyped, interpreted language in domains and use cases where traditional wisdom would suggest the need for a typed, compiled language.

    But APL is not like other languages, and its unique features and historical uses warrant a careful revisiting of the question of type systems. In this talk we will explore whether or not APL needs a type system, whether it would benefit from having one, what that might look like, and how the interaction between APL and type theory might inform the design and use of type systems in general.

  • Added to My Schedule
    keyboard_arrow_down
    Harendra Kumar

    Harendra Kumar - High Performance Haskell

    schedule 11:45 AM - 12:30 PM place Crystal Ball Room 2 people 10 Interested

    Haskell can and does perform as well as C, sometimes even better. However,
    writing high performance software in Haskell is often challenging especially
    because performance is sensitive to strictness, inlining and specialization.
    This talk focuses on how to write high performance code using Haskell. It is
    derived from practical experience writing high performance Haskell libraries. We
    will go over some of the experiences from optimizing the "unicode-transforms"
    library whose performance rivals the best C library for unicode normalization.
    From more recent past, we will go over some learnings from optimizing and
    benchmarking "streamly", a high performance concurrent streaming library. We
    will discuss systematic approach towards performances improvement, pitfalls and
    the tools of the trade.

12:30

    Lunch Break - 45 mins

01:15
  • Added to My Schedule
    keyboard_arrow_down
    Debasish Ghosh

    Debasish Ghosh - Managing Effects in Domain Models - The Algebraic Way

    schedule 01:15 PM - 02:00 PM place Crystal Ball Room 1 people 5 Interested

    When we talk about domain models, we talk about entities that interact with each other to accomplish specific domain functionalities. We can model these behaviors using pure functions. Pure functions compose to build larger behaviors out of smaller ones. But unfortunately the real world is not so pure. We need to manage exceptions that may occur as part of the interactions, we may need to write stuff to the underlying repository (that may again fail), we may need to log audit trails and there can be many other instances where the domain behavior does not guarantee any purity whatsoever. The substitution model of functional programming fails under these conditions, which we call side-effects.

    In this session we talk about how to manage such impure scenarios using the power of algebraic effects. We will see how we can achieve function composition even in the presence of effects and keep our model pure and referentially transparent. We will use Scala as the implementation language.

    In discussing effects we will look at some patterns that will ensure a clean separation between the algebra of our interface and the implementation. This has the advantage that we can compose algebras incrementally to build richer functionalities without committing to specific implementations. This is the tagless final approach that offers modularity and extensibility in designing pure and effectful domain models.

  • Added to My Schedule
    keyboard_arrow_down
    Srihari Sriraman

    Srihari Sriraman - Generative Testing Patterns

    schedule 01:15 PM - 02:00 PM place Crystal Ball Room 2 people 2 Interested

    Tests are good. Generative tests are better. But we don't write them often enough. Why not?

    Generative testing isn't new; John Hughes' QuickCheck is now implemented in 30 languages. Yet, it is still not an every day tool for most software teams. Why not?

    I have seen that maintaining a generative, or simulation testing suite can require the full-time attention of a few senior engineers. And over time, the tests become complex, brittle, ineffective, and hard to diagnose.

    But isn't generative testing supposed to make testing simpler, and more effective?

    I believe that it requires a rather different paradigm of thought from what we're used to with traditional testing. And recognising this paradigm shift can help us leverage it effectively.

    I'll discuss a holistic perspective of generative testing to elucidate this thought paradigm.

    Using a practical scenario, I'll discuss the patterns that emerge from this thinking, and how they address the concerns of making generative tests more effective, and maintainable.

02:15
  • Added to My Schedule
    keyboard_arrow_down
    Anne Ogborn

    Anne Ogborn - Declarative Expressions of Behavior

    schedule 02:15 PM - 03:00 PM place Crystal Ball Room 1 people 4 Interested

    We write programs in a different language than we talk about them. "So we get a request, do the security mumble, pass it to the middleware that grabs ..."

    Can we get closer to writing programs that describe the program's desired behavior? And why do such attempts always get poo-pooed by programmers?

    This is a foofy cloud shaped drawings exploration of other ways to express software design intent, mostly by cheating.

  • Added to My Schedule
    keyboard_arrow_down
    Stavros Aronis

    Stavros Aronis - Conquering race conditions in Erlang programs with Concuerror

    schedule 02:15 PM - 03:00 PM place Crystal Ball Room 2

    Concurrency-related bugs, such as race conditions and deadlocks, are some of the hardest bugs to isolate, reproduce, understand and fix. Even Erlang programs can suffer from such bugs, for example when messages arrive in unexpected orders or shared resources (e.g. ETS tables) are accessed concurrently. In this workshop I will demonstrate how developers of all levels can use Concuerror, a testing and verification tool for Erlang programs, to automatically detect, isolate and understand concurrency-related errors in their code and explain how the tool can ultimately prove the absence of such errors. I'll also share experiences from two industrial applications of Concuerror in verifying interesting aspects of distributed algorithms.

03:00

    Coffee/Tea Break - 30 mins

03:30
  • Added to My Schedule
    keyboard_arrow_down
    Jayaram Sankaranarayanan

    Jayaram Sankaranarayanan - Ring Of Effects Architecture Driven by FP!

    schedule 03:30 PM - 03:50 PM place Crystal Ball Room 1 people 3 Interested

    This talk shares case study on how an application's design and architecture evolved when functional principles were applied and application was refactored.

    The transformation of the architecture and how developers understood the structure of the application is also discussed.

    It starts with outlining the basic use case, initial implementation tech stack and high level design and how iteratively the design was changed by applying the following FP principles.

    1. No mutable global state

    2. Use pure functions

    3. Effects as Data and Restrict effects to outer ring of the application

  • schedule 03:30 PM - 03:50 PM place Crystal Ball Room 2 people 1 Interested

    Functional programming is built around a foundation of well-defined Types, and when you throw in Typeclasses into the mix, you get the love-child that is Algebraic Data Types. In this talk I aim to explore the mathematical foundations of Type theory and how it can be used practically in Scala for wide variety of applications like Machine Learning (Apache Spark MLlib), API design (using Vertx), DSLs and the like.

    I will also be introducing the scalacheck library for Property-based testing and how you can quickly validate your ADT domains.

    The talk will further deep-dive into how you can utilize the amazing Cats library and Shapeless to build generic libraries around your ADTs, having Circe as a case-study.

04:00
  • Added to My Schedule
    keyboard_arrow_down
    Aaron W Hsu

    Aaron W Hsu / Dhaval Dalal / Morten Kromberg - Array-oriented Functional Programming

    schedule 04:00 PM - 05:30 PM place Crystal Ball Room 1 people 2 Interested

    APL is the original functional programming language, the grand-daddy, the Godfather, and the old workhorse. But don't let Grandpa's age fool you. APL programmers have been leveraging the use of functional programming with arrays long before it was cool to be chasing pointers in an ADT using statically typed pattern matching, and they've refined their own style and approach to getting the most from a "functional paradigm."

    In this workshop, you will have the chance to spend some time thinking like a functional array programmer. What makes it different? How does the code look at the end? What thought process do you go through to get there? Get a chance to play around with some classic problems and try solving them "the APL way."

    Taijiquan Classics say, "Four ounces deflects a thousand pounds."

    APLers might say instead, "Fifty characters solve a thousand problems."

  • schedule 04:00 PM - 04:45 PM place Crystal Ball Room 2 people 4 Interested

    Easy concurrency is one of the main prophesied benefits of the modern functional programming (FP) languages. But the implementation of concurrency differs widely between different FP languages. In this talk, we shall explore the methods and primitives of concurrency across three FP languages: Haskell, Erlang, and Clojure (with core.async).

    We shall learn about and compare the trade-offs between

    • the green threads and STM channels oriented concurrency of Haskell
    • everything-is-a-process and message-passing actor pattern of Erlang
    • macro-based state machine code transformation of Clojure/core.async
04:45
  • Added to My Schedule
    keyboard_arrow_down
    Markus Hauck

    Markus Hauck - Free All The Things!

    schedule 04:45 PM - 05:30 PM place Crystal Ball Room 2 people 7 Interested

    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. Our journey starts with the well-known free monads, but after that we will have a look at all the other interesting structures that can be freed and of course we will also look at what we can do with them.

05:30

    Closing Talk - 15 mins

Post-Conf Workshop

Sun, Dec 16
09:30

    Registration - 30 mins

10:00
  • Added to My Schedule
    keyboard_arrow_down
    Tony Morris

    Tony Morris - Let's Lens

    schedule 10:00 AM - 06:00 PM place Board Room 1 people 10 Interested

    Let's Lens presents a series of exercises, in a similar format to the Data61 functional programming course material. The subject of the exercises is around the concept of lenses, initially proposed by Foster et al., to solve the view-update problem of relational databases.

    The theories around lenses have been advanced significantly in recent years, resulting in a library, implemented in Haskell, called lens.

    This workshop will take you through the basic definition of the lens data structure and its related structures such as traversals and prisms. Following this we implement some of the low-level lens library, then go on to discuss and solve a practical problem that uses all of these structures.

  • Added to My Schedule
    keyboard_arrow_down
    Ravindra Jaju

    Ravindra Jaju / Dhaval Dalal - The Clojuring: (hit rubber road)

    schedule 10:00 AM - 06:00 PM place Board Room 2 people 5 Interested
    distance(clojure-code, production)→ 0

    Clojure is capable of leveraging everything your JVM provides. And you are convinced of the benefits this LISP brings to your productivity. In this workshop, we target bridging the gap between your expressive and beautiful Clojure code, and the huge, daunting world of the Enterprise. With some small, helpful steps.

    We'll specifically target

    • Going beyond the linear flows - making core.async practical
    • Confidence building measures - Clojure spec
    • Demystifying the wormhole - JVM interop
    • Practical tidbits - Introducing Clojure to your existing apps
    • Graduating - Build tooling and publishing for both library and standalone application use-cases
  • Added to My Schedule
    keyboard_arrow_down
    Aaron W Hsu

    Aaron W Hsu / Morten Kromberg - APL Workshop Intensive

    schedule 10:00 AM - 06:00 PM place Board Room 3 people 5 Interested

    This is an intensive workshop for those who are interested in learning how to think, read, and write APL. It will help give you the tools, mental framework, and structure for doing things "the APL way." In this workshop, you will have the chance to spend intensive time thinking like an APL programmer. What makes it different? How does the code look at the end? What thought process do you go through to get there? Get a chance to play around with a wide array of problems and solving them "the APL way."

    Taijiquan Classics say, "Four ounces deflects a thousand pounds."

    APLers might say instead, "Fifty characters solve a thousand problems."