Mastering Haskell Programming Online Course

About the Course

Haskell is a lazy, purely-functional programming language with a very precise type system. Each of these features make Haskell quite different from mainstream object-oriented programming languages, which is where Haskell's appeal and its difficulty lie.

In this course, you’ll discover different ways to structure interactions between the program and the outside world. We’ll look at some subtler aspects of the IO monad, such as lazy IO and unsafePerformIO. In addition to the IO monad, we’ll also check out two other structured forms of interaction: streaming libraries and functional reactive programming.

Then we explore parallel, concurrent, and distributed programming. Thanks to purity, Haskell is especially well-suited for the first two, and so there are a number of approaches to cover. As for distributed programming, we focus on the idea of splitting a large monolithic program into smaller microservices, asking whether doing so is a good idea. We’ll also consider a different way of interacting with other microservices, and explore an alternative to microservices.

By the end of this course, you’ll have an in-depth knowledge of various aspects of Haskell, allowing you to make the most of functional programming in Haskell.

Course Curriculum

Tracking Side-Effects Using IO

• The Course Overview
• Installation and Setup
• IO as a "Sin Bin"
• Exception Handling
• Fewer Sins Using the Free Monad
• Benign Side-Effects Using unsafePerformIO
• Simple Streaming Using Lazy IO

Chaining Side-Effects Using Streaming

• Pure Streaming Using Lazy Lists
• Composing Finite and Infinite Streams
• Who's Driving? Push, Pull… or Both!
• Transforming Effectful Streams Using the Free Monad

Interactive Applications Using Functional Reactive Programming

• Events, Behaviors, and Signals
• Local and Global States
• Higher-Order Signals and Time Leaks
• Pure, Monadic, and Arrowized APIs
• Continuous, Synchronous, Total Time

Parallel Programming in Haskell

• Parallel and Concurrent Algorithms
• Manual Parallelism Using the Free Applicative
• Laziness and Parallelism
• Purity and Parallelism
• Deterministic Communication Using IVars
• Deterministic Collaboration Using LVars

Concurrent Programming in Haskell

• Manual Concurrency Using forkIO
• Taming Asynchronous APIs Using ContT
• Opportunistic Concurrency Using Async
• Laziness and Concurrency
• Manual Signaling Using MVars
• Automatic Signaling Using TVars
• Effect Tracking and Concurrency

Distributed Programming in Haskell

• Combinator Libraries
• Monad Transformers
• Nesting Architectures
• Precise Types, Program Boundaries, and Microservices
• Optimizing Microservice Requests Using Haxl
• Distributed Concurrent Programming Using Cloud Haskell
• CRDTs, Type Class Laws, and Eventual Consistency