2019 Schedule

Purchase tickets

Day 1
07:30 - 08:30
Opening Remarks
08:30 - 09:00
Poka yoke: Mistake-proofing via Functional Programming

“Poka yoke” (po-kah yo-kay) is a term from Japanese manufacturing that means “mistake proofing”. It is a powerful concept (equally powerful in software) in which the design of a system shapes usage so that human error is prevented or corrected before it can cause real harm. In this session we will explore how and why FP maps so well onto the poka yoke concept. We will discuss the merits of mistake proofing over diligence, and rethink our approaches to craft and quality. You will leave with a new lens to evaluate languages, tools, and your own code. Examples in Elixir, Elm, F#, and Idris.

09:00 - 09:45
Bryan Hunter avatar
How Functional Programming Made Me a Better Developer

With the rise in popularity recently, functional programming has become “”The Next Big Thing””. As of today, there are tons of frameworks and tools that can be used for front-end, back-end, desktop, and mobile development. With that being said, the majority of us are still using object-oriented languages for our day jobs and don’t need to learn functional programming, right?

In this talk, I’ll walk you through my experiences learning functional programming over the last year, how my style of programming has changed, and how I now think about programming with regards to both functional and object-oriented paradigms.

10:00 - 10:45
Cameron Presley avatar
It’s Endomorphin’ Time! Composure in JavaScript, from Functions to Monads

One of the greatest tools in the functional programmer’s tool belt is the notion of composure. It’s a pattern that allows you to take two things and combine them, like LEGO pieces or the segmented tracks of a train set, and join them together in a myriad of ways with different structures or pathways each time.

Combined with functors and monads, this very simple concept can be used not only to transform data in complex ways, but also ensure its validity and handle errors and invalid input effortlessly without ever causing your program to crash.

This talk will start with the basic building blocks of function composition— pure, endomorphic functions— and then discuss how curry and compose assist in combining these blocks. It will illustrate how functors can be used when the presence or type of input is uncertain, how monads can provide multiple validity checks without breaking a sweat, and how map and chain let us continue to compose away effortlessly under these circumstances.

Examples will be in JavaScript and will utilize the Ramda library for helper functions and monads, however this talk will also take a look at how these things work internally so as to demonstrate not only how to use these tools, but also how they work.

Understanding and utilizing composure to solve real world problems in programming will produce code that is clean, agile, and reliable. These benefits are accessible to both the seasoned developer and the beginner.

11:00 - 11:45
Jake Witcher avatar
12:00 - 13:30
Solving the Boolean Identity Crisis

Powerful in its simplicity, the boolean can be limiting. In this talk, we will look at examples where booleans obscure the meaning of code and make it harder to maintain. You will learn patterns such as ADTs to write clear code without booleans and gain greater empathy for your teammates and users.

The primary goal of this talk is to teach attendees the importance of usability in the code they write and UIs they design. At some level I hope to encourage attendees to developer better empathy towards others in this process. My vehicle for exploring this topic will be misuse of booleans in Elm. Therefore, the practical, secondary goal of my talk is to teach attendees how to write cleaner code by using union types and higher-order functions instead of booleans. I want attendees to learn that union types and higher-order functions help declaratively model intent and domains in code better than booleans.

13:30 - 14:15
Jeremy Fairbank avatar
When types aren't enough - Contracts for building robust systems

It’s mentally taxing to work in a system with a large number of services. One of the ways to combat that cognitive load is to use types to specify contracts between services. This system works well if you need to know if a key is a string or an integer.

But it turns out types fall short in their ability to specify the important properties of your system. At bleacher report we’ve been feeling this pain accutely. In order to remedy this problem we’ve been building our own contract system. These contracts are applied at runtime and provide a common language for specifying the data moving through your system.

In this talk we’ll discuss the tradeoffs between type systems and contract systems, we’ll show the decisions that we made in our contract language, and finally discuss how to implement a basic system for specifying data.

14:30 - 15:15
Chris Keathley avatar
Front to Back and Beyond

Can a programming language be both fish and fowl? And what about other forms? Can one language rule them all? This talk says yes! See what is common between these kinds of programming. And the unique requirements each has that a influence the design of gradually typed, FP language.

Software is eating the world faster now than ever. Programming is a skill that is applicable to wide range of contexts. There’s a common divide between “backend” and “frontend”. Not to mention, scripting and apps. There are common threads that run through all these areas. And each area has their unique demands and populations of developers. This talk looks at what these commonalities and differences are and how they can be addressed in one Functional Programming language that is Gradually Typed.

15:30 - 16:15
Jim Duey avatar
This website uses cookies. By continuing to browse you agree to this and Conferize's terms of service.