O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Mastering Haskell Programming

Video Description

Harness the power of functional programming with advanced Haskell concepts

About This Video

  • Dive into various important features such as IO, distributed programming, and Functional Reactive Programming

  • Learn the best practices in Haskell and alternative solutions to real-world situations

  • Explore powerful parallel algorithms, and build interactive applications using functional reactive programming

  • In Detail

    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.

    Table of Contents

    1. Chapter 1 : Tracking Side-Effects Using IO
      1. The Course Overview 00:05:30
      2. Installation and Setup 00:04:40
      3. IO as a “Sin Bin” 00:14:28
      4. Exception Handling 00:09:25
      5. Fewer Sins Using the Free Monad 00:14:35
      6. Benign Side-Effects Using unsafePerformIO 00:06:34
      7. Simple Streaming Using Lazy IO 00:08:51
    2. Chapter 2 : Chaining Side-Effects Using Streaming
      1. Pure Streaming Using Lazy Lists 00:09:53
      2. Composing Finite and Infinite Streams 00:10:14
      3. Who's Driving? Push, Pull… or Both! 00:10:09
      4. Transforming Effectful Streams Using the Free Monad 00:08:09
    3. Chapter 3 : Interactive Applications Using Functional Reactive Programming
      1. Events, Behaviors, and Signals 00:08:41
      2. Local and Global States 00:09:46
      3. Higher-Order Signals and Time Leaks 00:12:38
      4. Pure, Monadic, and Arrowized APIs 00:13:08
      5. Continuous, Synchronous, Total Time 00:12:20
    4. Chapter 4 : Parallel Programming in Haskell
      1. Parallel and Concurrent Algorithms 00:11:36
      2. Manual Parallelism Using the Free Applicative 00:11:07
      3. Laziness and Parallelism 00:08:59
      4. Purity and Parallelism 00:14:04
      5. Deterministic Communication Using IVars 00:13:23
      6. Deterministic Collaboration Using LVars 00:10:46
    5. Chapter 5 : Concurrent Programming in Haskell
      1. Manual Concurrency Using forkIO 00:04:42
      2. Taming Asynchronous APIs Using ContT 00:12:10
      3. Opportunistic Concurrency Using Async 00:05:01
      4. Laziness and Concurrency 00:08:36
      5. Manual Signaling Using MVars 00:09:48
      6. Automatic Signaling Using TVars 00:12:50
      7. Effect Tracking and Concurrency 00:10:38
    6. Chapter 6 : Distributed Programming in Haskell
      1. Combinator Libraries 00:11:31
      2. Monad Transformers 00:10:37
      3. Nesting Architectures 00:09:16
      4. Precise Types, Program Boundaries, and Microservices 00:10:45
      5. Optimizing Microservice Requests Using Haxl 00:07:56
      6. Distributed Concurrent Programming Using Cloud Haskell 00:08:43
      7. CRDTs, Type Class Laws, and Eventual Consistency 00:12:54