Mastering Haskell Programming
4.5 (1 rating)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
85 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Mastering Haskell Programming to your Wishlist.

Add to Wishlist

Mastering Haskell Programming

Harness the power of functional programming with advanced Haskell concepts
Bestselling
4.5 (1 rating)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
85 students enrolled
Created by Packt Publishing
Last updated 4/2017
English
Current price: $10 Original price: $125 Discount: 92% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 6 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Find out how to structure larger Haskell programs
  • Use the Parsec library to easily parse structured inputs
  • Get acquainted with the process of writing an interpreter, a type checker, and a compiler
  • See how to model your problem domain with precise types and how to reap the benefits of doing so
  • Work with Deterministic Communication using IVars and Deterministic Collaboration using LVars
  • Understand how to do concurrent and distributed programming in Haskell
  • Know how to cope with the uncertainties of communication in a distributed application
View Curriculum
Requirements
  • Students who already know how to write basic Haskell programs can follow this course to expand their toolbox with a variety of techniques for writing programs in a way which eliminates entire classes of bugs, such as deadlocks, merge conflicts, race conditions, and "time leaks".
  • This course has the following software requirements:
  • You'll need the Glasgow Haskell Compiler, which is available for Mac/Windows/Linux. Please install it via stack in order to ensure you use the same version as the one which was used to create the slides.
  • Optionally, to use git-slides to navigate the slides more easily to and to run the scripts which automatically run the code as it appears like it does in the video, you'll need Bash.
  • This course has been tested on the following system configuration: 2014 laptop with OS X Yosemite
Description

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.

About the Author

Samuel Gélineau is a Haskell developer with more than 10 years of experience in Haskell Programming. He has been blogging about Haskell for about the same time. He has given many talks at Montreal’s Haskell Meetup, and is now co-organizer.

Samuel is a big fan of functional programming, and spends an enormous amount of time answering Haskell questions on the Haskell subreddit, and as a result has a good idea of the kind of questions people have about Haskell, and has learned how to answer those questions clearly, even when the details are complicated. Apart from Haskell, he is a fan of Elm, Agda, and Idris, and also Rust.

Who is the target audience?
  • This course includes in-depth content balanced with tutorials that put theory into practice. It will give you both an understanding and practical experience, enabling you to indulge in the art of functional programming with Haskell while taking you through core concepts.
  • This course is for developers who are familiar with the Haskell programming language and functional programming in general, and who want to get more in-depth knowledge of the language as well as getting to know a number of techniques that will help them become experts in Haskell programming.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
36 Lectures
06:04:10
+
Tracking Side-Effects Using IO
7 Lectures 01:03:58

This video gives an overview of the entire course.

Preview 05:29

In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

Installation and Setup
04:39

In this video, we will look at the wide variety of side-effects supported by the IO monad.

IO as a "Sin Bin"
14:27

In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

Exception Handling
09:24

In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

Fewer Sins Using the Free Monad
14:34

In this video, you will learn how and when to use unsafePerformIO to execute side-effects within pure code.

Benign Side-Effects Using unsafePerformIO
06:34

In this video, we will examine how lazy IO is implemented, and how the same underlying mechanism can be used to express effectful stream transformations.

Simple Streaming Using Lazy IO
08:51
+
Chaining Side-Effects Using Streaming
4 Lectures 38:23

In this video, we introduce streams and demonstrate how laziness makes it easy to implement streaming algorithms in Haskell.

Preview 09:53

In this video, we explore the consequence of a design in which streams are allowed, guaranteed, or forbidden from terminating after a finite number of elements, and similarly for stream transformers terminating after a finite number of steps.

Composing Finite and Infinite Streams
10:14

In this video, we explore two variants of a callback-based APIs: push-based and pull-based.

Who's Driving? Push, Pull… or Both!
10:08

In this video, we explore another alternative API in which the focus is on the streams instead of the stream transformers.

Transforming Effectful Streams Using the Free Monad
08:08
+
Interactive Applications Using Functional Reactive Programming
5 Lectures 56:32

In this video, we will introduce the fundamental abstractions on which Functional Reactive Programming is based.

Preview 08:41

In this video, we look at the way in which FRP libraries handle state, and compare this approach to the way in which state is handled by traditional callback-based systems. 

Local and Global States
09:45

In this video, we look at FRP operators which allow the FRP network to be changed dynamically.

Higher-Order Signals and Time Leaks
12:38

In this video, we look at three ways to specialize the type of the switch operator in order to eliminate time leaks.

Pure, Monadic, and Arrowized APIs
13:08

In this video, we look at the properties of time which are either required or provided by FRP implementations.

Continuous, Synchronous, Total Time
12:20
+
Parallel Programming in Haskell
6 Lectures 01:09:53

What is "Parallel Programming in Haskell" about, and how does it differ from "Concurrent Programming in Haskell?" We answer those questions by clarifying the meaning of a few terms which are frequently confused.

Preview 11:36

How to specify which parts of an algorithm should be executed in parallel?

Manual Parallelism Using the Free Applicative
11:07

In this video, we turn laziness from a source of bugs into a source of parallelism opportunities.

Laziness and Parallelism
08:58

In this video, we see how purity and immutability makes Haskell a great fit for writing parallel algorithms. 

Purity and Parallelism
14:04

In this video, you will learn how to write programs whose outcome is deterministic even though the interleaving of its threads is not.

Deterministic Communication Using IVars
13:22

In this video, we look at a generalization of IVars which preserves determinism while allowing more than one thread to modify each variable.

Deterministic Collaboration Using LVars
10:46
+
Concurrent Programming in Haskell
7 Lectures 01:03:44

In this video, we look at a few gotchas when writing code which forks threads.       

Preview 04:44

In this video, you will learn how to turn an asynchronous API into a synchronous API and vice versa.

Taming Asynchronous APIs Using ContT
12:09

If our problem is not composed of smaller identical subproblems, can we still benefit from concurrency?

Opportunistic Concurrency Using Async
05:00

In this video, we draw inspiration from laziness in order to delay blocking for child thread until the last possible moment.       

Laziness and Concurrency
08:35

In this video, we introduce a way for threads to sleep until another thread wakes them up. 

Manual Signaling Using MVars
09:48

In this video, we introduce software transactional memory, a radically simpler way to write concurrent programs.

automatic Signaling Using TVars
12:50

In this video, we see how purity and effect-tracking makes Haskell a great fit for writing concurrent algorithms.

Effect Tracking and Concurrency
10:38
+
Distributed Programming in Haskell
7 Lectures 01:11:40

In this video, we show that while writing code in the style of a combinator library has advantages, making it easier to write distributed programs is not one of them.

Preview 11:31

In this video, we investigate whether writing code in the style of a monad transformer stack also makes it harder to write distributed programs.

Monad Transformers
10:36

How can we use more than one architectural style, such as combinator libraries or monad transformers, in the same Haskell program? 

Nesting Architectures
09:16

In this video, we examine whether microservices are a good fit for a distributed Haskell application.

Precise Types, Program Boundaries, and Microservices
10:45

In this video, we optimize the set of requests being sent to a number of other services.        

Optimizing Microservice Requests Using Haxl
07:56

In this video, we introduce a different way to structure a distributed application, by launching remote threads instead of performing remote calls.

Distributed Concurrent Programming Using Cloud Haskell
08:43

This video introduces data structures which are designed to cope with the uncertainties of communication in a distributed application.

CRDTs, Type Class Laws, and Eventual Consistency
12:53
About the Instructor
Packt Publishing
3.9 Average rating
7,282 Reviews
51,875 Students
616 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.