On the surface, function types simply describe inputs and outputs—indeed, that's how they're used in most type systems. But there's more to function types!

Fascinatingly, a function type can be transformed into a data flow graph that predicts the inner workings of any function that has that type. Using this graph, intricate dependencies between function inputs and outputs can be inferred without having to read code or documentation.

In this talk you will learn how to see function types in a different light, gaining clairvoyant powers to predict how their implementations behave.

We will cover how this insight enables the impressive type inference of Flow and MLsub, and explore possible future applications to other languages like TypeScript, Typed Racket, and Typed Clojure.

Property-based testing is a popular testing concept, which came from the world of Functional Programming. QuickCheck in Haskell is an iconic framework, which introduced us to this idea. Today we can find testing libraries supporting PBT in any main-stream languages, including Scala, JavaScript, Ruby, Python, Java, etc.

We all like the idea of building high quality and robust code, covering all the possible and impossible edge cases. Maybe this is why many of us are getting hooked on the Property-based testing approach or at least we are not opposed to try it out.

It gives us an ability to run a single test case hundreds of times on a large range of data, covering edge cases we’ve never thought we had in the first place.

However, if you are like me and your day-to-day job is to create an API and save data into a database or maybe even send it over to another API, you also probably struggled to come up with a good application of this practice. It is easy and “very useful” to test that a reverse of a collection is still working. But, when it comes to if-else conditions, we find it hard to come up with the right property to test.

In this talk I would like to focus on a practical application of this concept, presenting some examples in ScalaCheck. I will start with a summary of what Property-based testing (PBT) framework equips you with and what should you expect from it. There will be basic examples demonstrating the power of PBT. But mostly, I will cover existing patterns and tips you can take to your normal life projects and use them to leverage this PBT tool.

Programming language design is kind of like world building. This is what initially got me excited about it! In this talk I'll take you on journey, showing how I originally became excited about programming languages as a result of my artistic interests. I'll then cover why we are excited about programming languages and dependent types at YesLogic, and share some of the struggles I've had in applying academic research to industrial problems.

Functional Reactive Programming (FRP) is often introduced by discussing events and behaviors, and how to transform and mix them. But once you understand the primitives, what do you do with them? Where do the first events come from, and how do you wire these parts into a larger whole?

FRP promises benefits in more domains than just user interfaces, so let's take a look at Reflex outside its most common habitat of web frontends. There's now a fairly up-to-date version of Reflex on Hackage, so we can play with it right away and leave GHCjs, Reflex-DOM, special build tools, and the custom nix frameworks for later.

An FRP network of events and behaviors runs inside a library called a "host", which interfaces between the FRP network and the outside world. Using an interactive OpenGL program as our example, we'll explore how a slightly larger reactive program hangs together, and how it uses the host's features to do what it needs to do.

The propagator model of computation developed by Radul and Sussman consists of stateful cells connected by independent stateless machines called propagators. These propagator networks are a helpful way to structure or think about computations, particularly those that are concurrent or distributed.

This talk will give an intuition for what these propagator networks look like, why they work, and how we can use them to build programs. Efficient implementation will not be covered.

The Haskell community has recently seen concurrency abstractions bearing similarities to propagators, such as the work on LVars by Kuper and Newton; and also projects directly influenced by propagators, such as Edward Kmett's recent work.

Over the last 16 years, Scala has become one of the most widely used FP languages, and has had a profound influence on newer languages like Swift, Kotlin and recent versions of Java and C#.

It is also about to receive a dramatic overhaul! Scala 3, due to be released next year, adds, modifies and deletes dozens of features currently in Scala 2. These aim to simplify common workflows, discourage bad practices, encourage good practices, and in some cases, are bold innovations. The current beta version is not yet production-level stable, but the feature set is expected to largely be the same for general release.

Let's learn it!

Whether you're a grizzled Scala veteran or new to Scala & FP, this workshop will help you get going with Scala 3, get familiar with the features and how to use them.

As part of Melbourne :: Compose 2019 I'm running - for the second time - a short introductory Haskell workshop called 'Crashkell'.

Over the last few years I've run previous versions of the workshop, but based on past feedback…

'Less Talking, More Typing!'

I reworked the content to…

• Be instantly accessible via the web, with no setup required
• Have no lecture material, being composed entirely of exercises
• Progressively teach concepts without requiring jumping around
• Be completely broken! Every exercise will crash, requiring debugging

Crashkell leverages Jupyter notebooks and the MyBinder platform to allow attendees to be up and running instantly. Jump directly into exercises with no section introductions and get immediate feedback inline, without the requirement to install any tools.

About the format of the workshop - The examples are broken by design. The flow of interaction is to run the exercise, look at the error, and work towards fixing the error while considering the meaning, and the motivation of the exercise. This is a great way to learn for a few reasons…

• It prevents you from skipping through the code without reading
• It teaches you how to interpret the languages error messages
• It removes anxiety about breaking the code, since it starts broken
• It facilitates discussion among groups of attendees
• And finally, It forces the content author to consider the order of the introduction of concepts

I look forward to seeing you there!

The Nix/NixOS ecosystem is a new way of building software.

Nix is a powerful package manager for Linux and other Unix systems that makes package management reliable and reproducible. It provides atomic upgrades and rollbacks, side-by-side installation of multiple versions of a package, multi-user package management and easy setup of build environments.

NixOS is a Linux distribution with a unique approach to package and configuration management. Built on top of the Nix package manager, it is completely declarative, makes upgrading systems reliable, and has many other advantages.

This workshop introduces attendees to using, developing on, and developing for Nix and Nixos.

Some knowledge of unix-like command lines and some programming experience are required, but we'll assume no prior knowledge of Nix and NixOS themselves.

Please bring your laptop with a recent copy of VirtualBox installed on it.