Mastering Haskell Programming Online Course

Mastering Haskell Programming Online Course

About the Course

Haskell is a lazy, purely functional programming language known for its rigorous type system. These distinctive features set it apart from mainstream object-oriented languages, offering both unique advantages and certain challenges.

In this course, you'll explore various ways to manage interactions between Haskell programs and the outside world. We'll delve into advanced concepts of the IO monad, including lazy IO and the use of unsafePerformIO. Beyond the IO monad, you'll also be introduced to structured interaction patterns through streaming libraries and functional reactive programming (FRP).

Next, we turn to parallelism, concurrency, and distributed computing. Haskell’s purity makes it particularly well-suited for parallel and concurrent programming, so we’ll examine several techniques in these areas. For distributed systems, we’ll consider breaking monolithic applications into microservices—evaluating when this is beneficial—and also explore alternative approaches to service-oriented design.

Who should take this Course?

The Mastering Haskell Programming Online Course is ideal for functional programming enthusiasts, software developers, computer science students, and researchers who want to gain a deep understanding of Haskell for building robust, maintainable, and mathematically sound software. It’s also suitable for professionals exploring advanced programming paradigms or transitioning from imperative to functional languages. Prior programming experience and a basic understanding of functional programming concepts or mathematics is recommended for effective learning.

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