Speakers

Opening Keynote: There and Back Again

Mathematicians usually teach abstract algebra from groups and build up from there. Having inverses allows them to prove many non-trivial results. Functional programmers more often descend to working with monoids, or even semigroups. They give up the power of inverses to gain many more examples. You don't often hear about the shadowy realm between. Perfect inverses don't always exist, nor do we want them to. Going on a journey and returning rarely leaves the protagonist unchanged. If it does, this is usually taken as a poor example of the author's craft. We'll explore the middle-ground of regular and inverse semigroups, inverse monoids, even inverse categories. In this space where inverses may not invert, we'll develop examples and counter-examples. We'll gain some insight into spoken Australian English along the way. Join us.

How to look like a statistician: a developer's guide to probabilistic programming

Probabilistic programming integrates standard programming with probabilistic machine learning - and allows people to write probabilistic models without having to care about how they are evaluated and all the mathematical details underneath.

In the talk, I'll show you what is probabilistic programming about, how it works and how you might include probability distributions into F# - and mainly why you don't need a PhD in statistics to write a Bayesian machine learning model.

Introduction to the Unison programming language

Unison is a new purely functional programming language, currently under development. Unison treats any pool of networked machines as if they formed a single supercomputer, and lets you program this supercomputer simply and directly. This talk will introduce the Unison language, its type system, runtime, and developer experience, as well as the core ideas that make Unison unique.

What FP can learn from Smalltalk

I love functional programming, especially with types, my code is less buggy, easier to test, reuse, and document. But something is missing. In the quest for correctness we have denied ourselves a crucial (and fun!) aspect of programming: interactivity, visualizing, debugging and just plain playing around in your environment. This talk will dive into Pharo and Squeak, state of the art highly graphical, explorable and fully programmable Smalltalk environments focusing, not so much on Smalltalk the language, but on how well it integrates with the surrounding environment and why we should be stealing the ideas and design for functional programming.

Abstract your representations (and fix your functors)

Factoring in software development is the process of decomposing a complex problem or system into constituent parts which are easier to organize, understand, build, and maintain. So why do we refactor so often in our industry?

This talk will introduce the audience to approaches exploited in functional languages supporting parametric polymorphism and higher-kinded types. Leveraging these constructs allows us to re-compose parts of our system in a way that reduces (compared to conventional industrial techniques) the need to refactor large parts. Instead, we define much smaller pieces, passing them as arguments to reusable (already written) generalized patterns of computation.

Not only do we free ourselves from the underlying representation of our structures, this simplifies and reduces ongoing maintenance efforts, but we also get the benefit of termination guarantees and less cumbersome composition of data constructors.

Join us on an exploration of the promise of recursion schemes starting out by merely abstracting representation from our program's structure.

ScalaBridge Workshop

This is a free workshop intended to reach out to women, non-binary people, and all underrepresented populations who are interested in learning Scala.

Consensus Algorithms in Distributed Systems

Functional programming enables easy parallel and distributed computing. Many messaging systems that are widely used in the industry, e.g., Kafka, use centralized distributed systems services to achieve reliability and consensus between servers. Companies in the industry use the services; however, only a few of them understand the details of the protocols. This talk introduces the common distributed systems protocols implemented in functional programming underneath the popular services. It provides details of how the protocols, specifically Paxos and Raft, work, including how they elect leaders among servers, how they achieve consensus between machines, and how they reliably process and execute client commands. Therefore, it shows how the systems and services, which use the protocols, are enabled to have fault-tolerance, and to achieve confidentiality, integrity, authenticity, availability, etc. From the reliability and security point of view, the talk discusses how the protocols deal with machine failures, including leader failures and replicas failures. It shows the vulnerabilities and potential security issues exist in the protocols. Last but not least, we'll take a look at what we can do to avoid the vulnerabilities when applying the academic theories in the industry.

How to Talk to Your Compiler

Every time you compile (or interpret code interactively in GHCi), your compiler figures out a lot about your program and how it must work -- sometimes it seems to know more about what you're doing than you do! With a little bit of practice and a couple of tools, you can learn to ask for all the information it has, in order to help you write better code and learn faster. We will focus especially on using three GHC features that offer ways to see incremental type information about even very complex programs:

• Visible Type Applications is a relatively new GHC feature, but it's one of the first language extensions a Haskell learner should consider turning on. It shows you what a polymorphic function applied to a specific type will look like, particularly valuable in contexts where the presence of many single-letter type variables makes it hard to keep track of what's what.
• Type holes let you leave blanks in your function implementation. Due to GHC's rather powerful type inference, the type checker can tell you the type of the value that must fit into that hole
• The ScopedTypeVariables language extension allows you to add explicit type signatures to sub-terms. Especially with complex functions, adding explicit intermediate type information can help the compiler guide you through the implementation.

This workshop will be very 'hands on,' so please come with a working installation of GHC (8.0 or higher), some text editor you like using, and a willingness to see your compiler as a friendly helper rather than a dreaded adversary.

Architecting Typed FP Applications & Libraries in Kotlin with Λrrow

In this talk we will learn the fundamentals of Typed Functional Programming applied to Kotlin with the library Arrow and how we can architect applications and libraries that are polymorphic and composed of pure abstract functions using type classes. Arrow provides a unified programming model in by which Kotlin practitioners can build programs relying on the traditional FP, MTL and Effect type classes in a Tagless Final style offering levels of flexibility and techniques new to the Kotlin FP community.

Bringing the Jewels of the Python world to Scala with Spark

With the new Apache Arrow integration in PySpark 2.3, it is now starting become reasonable to look to the Python world and ask “what else do we want to steal besides tensorflow”, or as a Python developer look and say “how can I get my code into production without it being rewritten into a mess of Java?”. Regardless of your specific side(s) in the JVM/Python divide, collaboration is getting a lot faster, so lets learn how to share! In this brief talk we will examine sharing some of the wonders of Spacy with the JVM world, which still has a somewhat lackluster set of options for NLP & deep learning.

Fury: Rage Against the Ecosystem

Scala's ecosystem of libraries suffers a number of problems: binary compatibility is brittle, and publishing is slow, difficult, and puts a heavy burden on a few key members of the community to quickly publish libraries other people depend on. Longer chains of dependencies and cross-publishing to different targets mean we sometimes have to wait months for some releases, and it's holding the entire ecosystem back.

Fury is a new dependency manager, built upon Bloop, which aspires to shake up the Scala ecosystem with source-based dependencies, data-only builds and signed publishing with git, liberating users to focus on writing code without forcing library authors to change from familiar build tools.

Rethinking compilers with live coding

Live coding environments run your program on-the-fly as you write it. This makes development easier, but it is a challenge for compiler writers - textbook compiler architecture does not work for live coding systems.

I'll show interesting aspects of a live coding environment for The Gamma, its functional F# implementation and explain how the compiler differs from textbook examples. Along the way, you'll see practical code samples interesting for both web developers and programming language enthusiasts.

Building Purely Functional Microservices

In this workshop you will learn how to build a purely functional application from scratch and expose it as a microservice with Freestyle and Freestyle RPC.

This will be a hands on coding session where we will architect a small application based on Algebras and Modules that can be exposed as an RPC microservice supporting Protobuf and Avro serialization protocols.

For more information, visit:

• Freestyle Home
• Freestyle RPC
• Freestyle Intro

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

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

It will be presented as a live, example-driven demo. We will progressively grow logic for a little data-processing utility and finally package it as a standalone app.

Fully-documented workshop material will be available for at-home use. Workshop Goals:

• Acquire a 'feel' of Clojure, for further self-study/exploration.
• Learn how Clojurists usually think with Clojure to solve problems.
• See how it's not so hard to do surprisingly powerful things with a mere handful of 'primitive' functions, data structures, and ideas.
• Understand how to truly leverage the REPL + 'liveness' of the Clojure development experience.

• Try to explain Functional Programming theory or Clojure's innards. (Many free and paid tutorials and books do so very well.)
• Try to fully cover Clojure primitives/features. (That's homework!)
• Devolve into language wars, editor wars, syntax wars, type wars... (Life's too short, people.)
• Focus too much on tooling or operational things. (At least not while there's fun to be had!)

• Think of this as an exercise in 'constrained creativity'
• Ignore details, achieve much with as little know-how as possible.
• Focus on what things do; not what they are, or why they are.
• Inform your _intuition for doing things_, and then use that to dive deeper into all the juicy details at your own pace, later.

The Radix Tree: How IntMap Works

The Radix Tree (aka PATRICIA Trie) is an efficient data structure for key-value maps with integral keys. Radix tries come up in a wide range of applications like in-memory databases and the Linux kernel, and can be turned into a persistent data structure useful for functional code (Haskell's IntMap).

With pictures and code, I'll walk you through how the data structure works, what Haskell's implementation looks like under the hood and several ways it's useful in functional code. I'll finish with a look towards the future: a quick overview of the Adaptive Radix Tree, a recently published variation on normal Radix Trees with real potential.

While this talk will be Haskell flavored, the data structure itself and the general concepts are all language-agnostic

Lenses – Laparoscopic Surgery for your Objects

This workshop will focus on practical problems that are elegantly solved using Lenses. The workshop uses Scala and shows practical examples of how to make a Lens. You will learn how to make a Lens yourself (10 lines of Scala code) and will build several kinds of Lenses. This workshop purposely shies away from using a 3rd-party Lens library in order to facilitate a deeper understanding of how Lenses work.

• Things you can do with Lenses
• View the subpart
• Modify the whole by changing a subpart
• Compose a Lens with another Lens to go deeper
• Practical applications of Lenses
• The deep-copy problem
• A cache built using Lenses – A Lens backed by a Map
• Other important features
• They are composable
• You can reason about them equationally. If your Lens passes the Lens laws tests, it is correct
• Lens Laws
• Get-Put – If you modify something by changing its subpart to exactly what it was before, then nothing happens.
• Put-Get – If you modify something by inserting a particular subpart, then you get back exactly what you put.
• Put-Put – If you modify something by inserting a particular subpart and then modify it again, its exactly as if you only made the second modification.
• Prisms and Traversals – examples from real life

Intro to Functional Programming in Machine Learning: Using AI to Protect Life

Functional programming is an important part of recent machine learning success. Companies like Axon, Uber, Palantir, and Facebook use Spark ML to train machine learning models on massive data sets. In this workshop, you'll gain insight into how scalable machine learning solutions are built and deployed in the real world. You’ll learn how to use your functional programming background to hit the ground running solving real-world problems with machine learning & AI. After a brief introduction and overview of machine learning, we will dive deep into the benefits of functional programming when applied to machine learning. Our challenge to you during this session: build your own gunshot detector! This challenge offers you the opportunity to get your hands dirty digging into Spark ML with Scala and the provided data set. You'll get a first-hand look at how machine learning solutions can help save lives by identifying critical situations and increasing situational awareness. Be prepared to learn about concepts including Feature Extraction, Inference, Model Training, Testing, and Generalization, with this ultimate deep-dive into functional machine learning!

Closing Keynote

Functional Programming Unconference

Unconf talk: Define Once, Evaluate Anywhere: Building Repeatable and Correct Features at Stripe

Feature engineering can produce a never-ending set of gotchas - from bugs in features that aren’t defined the same way (or even in the same language) in training versus production to mistakes in recording when a feature or label was actually available that lead to unrealistically predictive models. I will discuss the system we built at Stripe leveraging evented data to enable model developers to quickly define (and test!) complex and highly predictive features in a single place in code and make them available for both training and real-time scoring eliminating some of these common classes of feature generation errors.

Functional Programming Unconference

Unconf talk: You Could Have Invented Itertools

Itertools is a functional-language-inspired Python standard library for working with lazy, infinite streams. But most Python programmers don’t think functionally; never consider using lazy, infinite streams; and miss out on ways to make their code cleaner and more efficient. In this talk I’ll motivate the use of lazy, infinite streams with fun examples; introduce you to the itertools library; and show how under the covers it’s not doing anything you couldn’t do yourself.

Functional Programming Unconference

Unconf talk: Making decisions under uncertainty with Scala

Rainier is a library for high-performance bayesian statistical inference in Scala. It provides an idiomatic functional API, similar to the probability monad, for modeling your beliefs and observations about the world, and produces predictions and optimized actionable decisions that fully account for the inherent uncertainty in your model. Under the covers, it relies on an efficient numerical engine that uses automatic differentiation, partial evaluation, vectorized computation, and Hamiltonian mechanics to sample efficiently from your model’s posterior. This talk will briefly cover the high-level API, and provide more depth on the implementation of the numerical engine.

Intro to Functional Programming in Machine Learning: Using AI to Protect Life

Functional programming is an important part of recent machine learning success. Companies like Axon, Uber, Palantir, and Facebook use Spark ML to train machine learning models on massive data sets. In this workshop, you'll gain insight into how scalable machine learning solutions are built and deployed in the real world. You’ll learn how to use your functional programming background to hit the ground running solving real-world problems with machine learning & AI. After a brief introduction and overview of machine learning, we will dive deep into the benefits of functional programming when applied to machine learning. Our challenge to you during this session: build your own gunshot detector! This challenge offers you the opportunity to get your hands dirty digging into Spark ML with Scala and the provided data set. You'll get a first-hand look at how machine learning solutions can help save lives by identifying critical situations and increasing situational awareness. Be prepared to learn about concepts including Feature Extraction, Inference, Model Training, Testing, and Generalization, with this ultimate deep-dive into functional machine learning!

ScalaBridge Workshop

This is a free workshop intended to reach out to women, non-binary people, and all underrepresented populations who are interested in learning Scala.