This video will develop motivation for learning a new approach to software development and a new and decidedly different programming language.

This video will outline the approach to managing complexity that functional programming FP encourages.

This video will talk about what Haskell has in common with other functional programming languages as well as the ways in which it is different.

This video will demonstrate some more realistic programs, incrementally built up from simpler programs. It will run them in GHC’s interpreted mode. We will see more Haskell syntax encounter more functions from Haskell’s standard prelude.

Haskell is a whitespace-sensitive programming language. It’s worth gaining some comfort with the indentation rules, even though they correspond—for the most part—to the “obvious” way to lay a program out. We’ll relate layout to lexical scoping of names.

Haskell employs a non-strict evaluation strategy which can be strange for newcomers to the language. Furthermore, we will inevitably write buggy code. GHCi has useful debugging capabilities that can allow to address both of these concerns.

We will drill deeper into values, function application and composition, and the various ways to declare functions.

So far, we have only skimmed over types and type signatures. You need to know enough to be able to read function declarations and build our own functions and values.

We’ve looked at built-in types and values and functions that use them; you need to learn how to define our own composite data types. This will use Haskell’s support for user-defined algebraic data types.

Haskell’s primary mechanism for implementing abstract data types is the type class. We need to know about some of the common built-in type classes as well as how to implement our own type classes and type class instances.

You learn all about declaring our own ADTs and creating values for them. Before we can really consume ADTs, you need to know how to extract values from them using pattern matching.

This video provides overview of the entire course.

The aim of this video is to introduce how to install Haskell on your computer.

The aim of this video is to introduce how to install Haskell on OS X.

The aim of this video is to introduce how to install Haskell on Windows

The aim of this video is to introduce how to install Haskell on Linux.

We want to get started with Haskell in a quick and engaging way, without having to start with a long lecture on syntax. So, to develop our familiarity with Haskell, we'll explore some of the basics, such as how to use and manipulate numbers and strings using 'ghci,' the interactive interpreter.

It's hard to write interesting programs with just simple types such as strings and numbers. In this video, we'll look at built-in data structures such as Lists and Tuples, and see how we might do a simple dictionary lookup using built-in functions and the Maybe type.

The interactive interpreter is a great tool, but we're not going to be able to write longer programs without breaking our text editor. In this video, we'll look at how to use ghci along with our source code files.

You can't do "Functional Programming" without functions. In this video, you'll learn about how to declare functions in Haskell and some of the important characteristics of Haskell functions—how they work with types, currying, and point-free style.

If you're worried that being a "strongly typed" language meant that Haskell's types would be restrictive, never fear! In this video, we'll see how to define not just synonyms, but new types, including recursive ones!

Now we've created our new data-type, how do we manipulate the data inside it? In this video, you'll learn how to calculate the Expression values that we created in the previous video, and look at how to do pattern matching on lists.

To make sure we're taking advantage of a solid structure to develop a more complicated application on, we'll create a project with 'stack.' We'll see how to structure our main module, library functions, and tests and look at how to develop, compile, and test the project.

In this video, we'll take the first steps towards declaring and displaying a simple grid of letters.

So we want to search the grid from left to right, right to left, top to bottom, and diagonally... phew! Let's keep things simple for now by searching just from left to right. We'll explore list manipulation functions and the similarities between the Bool and Maybe types.

Though we can now search the grid horizontally, we want to do it in all directions. The easiest way to do this isn't to make our function more complicated, but rather to learn how to transform our grid! We'll use a toolkit including 'map', 'reverse', 'transpose', and our own recursive functions to do this.

Although Haskell's type system by itself gives you a lot of reassurance that you're writing correct code, good unit tests can help you maintain and understand your code even better.

You will learn how to associate every character on the word grid with a set of coordinates such as (2, 3) pointing at its position by row and column. We can accomplish this by learning more about Haskell's list type, including how to work with infinite lists, repeat values, iterate them with the List monad and list comprehensions, and join lists together with zip.

Using the grid coordinates from the previous video, we will explore how to declare a Cell datatype and incorporate that into our code. This will also give us a good experience of refactoring code. We'll do this using Haskell's type system.

In the previous video, we saw that the search functions couldn't be refactored in a simplistic, mechanical way. We now have to think about how to change a simple string search using 'isInfixOf' into something that searches on characters, but returns a complex Cell type.

The moment we've all been waiting for: we'll now turn all of our hard work learning about functions and data types into an actual game that we can play!

While we can now play our game, it still has a few rough edges. We'll now polish off a few of these. First, we want to create a random jumble of characters in the part of the grid that we're currently displaying with "underscore" characters. Next, we want to highlight each of the found words by uppercasing them.

This video gives an overview of the entire course.

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.

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

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.

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

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

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

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.

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

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

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

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.

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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