This track consists of a crash introduction to Haskell, in two parts of theory and practice. In the theory, we start from scratch and finish with the concepts of functions, type classes and algebraic data types. Armed with this knowledge we switch to the exercise track where we will implement two small games: Snake and Tetris.

Students will spend 6 sessions learning to apply practical Haskell programming techniques to the field of cryptography. Together we will explore the fundamental building blocks of modern cryptographic and functional programming techniques. We will focus on domain driven development leveraging the powerful type system of Haskell. Beginner Haskellers are welcomed, but should have a working knowledge of basics, for example function definition and application, where and let blocks. We will explore the following topics: discrete probability, the one time pad, pseudorandom generators, building attacks on ciphers, as well as exploring real world stream ciphers. This will be a fun, and hands on course that will combine lectures focusing on Haskell and Cryptography fundamentals with hands on exercises, projects, and a capstone. Students will leave feeling confident in leveraging Haskell’s type system, writing their own types, using instances of functors, monoids and applicative and take away experience writing and breaking cryptography algorithms.

In these sessions, Justin will go through various techniques used to make "Real World" applications work in PureScript. Topics will include FFI, using PureScript outputs from JavaScript, and various ways Row Type Classes can be used, whether to create a clean PureScript library or to provide more powerful interfaces for weakly-typed JavaScript libraries. Participants will walk away understanding how libraries like Simple-JSON and React-Basic work.

The talks will form a complete introduction to testing in Haskell. They will cover the different kinds of tests, and how to write them in Haskell, best practices and generators and their best practices. It will be a combination of lectures and hands-on workshops.

In this workshop, we'll make a simple website and along the way, learn basic Haskell concepts such as data types, type classes, the Maybe type, and the IO type. We'll use the beginner-friendly Fn web framework to create type-safe routes and write handlers for those routes, with views written in the Blaze templating language. The goal will be to show that writing real-world apps in Haskell can be fun and approachable, and to help attendees over some common initial stumbling blocks.

In Haskell we are used to design systems using types as both a guiding tool and verfication of desired properties. Session types allow to do that when developing protocols. In this course we will dive into this framework and develop an example protocol and prove it correctness (or rather let GHC prove it for us).

If you are not used to the pure functional paradigm, then dealing with arrays in Haskell can be very unintuitive, the code you write can become inefficient, especially if you choose the wrong library or an incorrect data structure for the job.

Throughout the series of talks and workshops I will cover some concepts about native arrays that every Haskell programmer should understand as well as provide concrete examples on how to deal with multidimensional arrays using the `massiv` library. First lectures will start with basic topics, such as memory representations and how to properly handle mutation. Then we will transition into more advanced notions of fusion, stencils and other ways of avoiding unnecessary computation, while taking advantage of automatic parallelization. Besides looking at many simple examples we will have hands on experience developing a more complex application that will reinforce the understanding of concepts introduced earlier.

Haskell is fantastic for industry use. The language can give you some nice correctness guarantees. This peace of mind can make software feel boring (in a good way). I want to convince you of this claim.

In this talk/workshop series, I'll show you how to write small but useful applications in Haskell. We'll talk about common patterns you need in a production setting (e.g. JSON, HTTP, and databases).

This interactive talk series explores the Comonad typeclass while solving real problems. Students are presented with practical examples to ground their understanding and cement their learnings by implementing the things they learn along the way. Git checkpoints are provided so nobody is left behind. The workshop-style series covers everything from "what's a comonad?" to using comonads for solving real problems, including simulating cellular automata and image processing!

Language is everything; it governs our lives: from our thought processes, our communication abilities and our understanding of the world, all the way up to law, politics, logic and programming. All of these domains of human experience are governed by different languages that talk to each other, and so should be your code. Haskell provides all the means necessary—and many more—to easily and safely use embedded small languages that are tailored to specific needs and business domains.

In this series of lectures and workshops, we will explore the whats, whys and hows of embedded domain-specific languages in Haskell, and how language oriented programing can bring type-safety, composability and simplicity to the development of complex applications.

I'll be giving a tour of the current state of the 'guanxi' library in Haskell. This is a framework I'm building for logic programming in the style of mini-Kanren.

GHC is getting linear types. I'll cover how you can use them, which of the common functions and classes can be made linear, interactions with other features of the language, theoretical underpinnings, future directions.

Build a merkle tree type meant to represent directory trees (as used by git, mercurial, etc) using recursion schemes, then use this to implement lazy diffing of arbitrary large merkle trees (real world problem for bigco monorepos), see an example implementation. We will dive into how functor composition can be used to build different merkle tree structures starting from various primitives (Maybe, [], Either a, (,) a, etc) - eg, did you know that type List a = Fix (Compose Maybe ((,) a)) and type NonEmptyList a = Fix (Compose ((,) a) Maybe)?

In this talk will start with the untyped lambda calculus and gradually build up towards simply typed, system F, system Fω and a dependently typed language. Particular attention will be paid to the parsing and type-checking issues that arise as the language increases in complexity.