Solve.hs

Do you feel like you're "fluent" in Haskell yet? If you're anything like I was a few years ago, you may have been trying out Haskell on the side for quite a while, but you haven't really gotten the hang of it yet. It still feels like a foreign language.

Whenever you want to write some code, it feels like you have to first think of that code in your head as if it were in a more common language like C++ or Python. You then have to translate that idea into Haskell, and it feels like a very arduous process each time. As a result, even relatively simple tasks seem to take quite a while for you to write, and so learning Haskell feels like a tiring task. You might be asking some of these seemingly simple questions:

1. How do I write for-loop code in Haskell?
2. Why is recursion so important in Haskell?
3. What convenience functions exist for list manipulation?
4. How do data structures work if Haskell is immutable?

We've now released the first part of our newest course, Solve.hs. This course is designed to improve your fluency in Haskell by teaching you the fundamental patterns of problem solving in this fascinating language. If this sounds interesting to you, head to the course sales page now!

If you want to learn more about the course, keep reading!

Course Content and Outline

This course is similar in structure to our other courses. The first core component is video lectures. You'll watch videos with accompanying slides while learning about a new set of essential ideas. Then, you'll try the ideas for yourself with our in-depth programming exercises. These exercises will give you the chance to try the ideas for yourself in your Haskell environment, with a battery of unit tests that will provide a quick feedback loop on whether or not you are able to implement the concepts.

Module 1: Lists and Loop Patterns

For now, the course has 2 modules (2 additional modules will be released in 2024). The first module covers Haskell's List type in great detail, showing the variety of different API functions you can use with it, as well as the patterns you can apply with the type. You'll get the chance to essentially rebuild the type from scratch yourself, including much of its core and even auxiliary API. This will help you practice the many list patterns out there, and give you a greater familiarity with the "shortcuts" that are available in the API!

Part of this module's focus is to reconstruct our most basic understanding of Haskell's list patterns in explicit terms. So while a fair amount of the material looks "simple" on the surface, this reconstruction will help us draw parallels to constructs in other languages (especially 'for' and 'while' loops). So it's worthwhile even if you've been working with Haskell for a while!

Module 2: Data Structures

Once we've covered lists, we'll move on to Module 2. There, we will survey the many other core structures that allow us to solve problems more efficiently. We'll learn about how Haskell's immutability causes some significant differences in how many of these structures are implemented! We'll learn what the performance implications of this are, and when this matters.

You'll also get the chance to implement a couple different structures from scratch, similar to the Module 1 work with lists (though we'll focus on core APIs here instead of auxiliary helpers).

FAQ

Who is this Course Good For?

This course is good for a wide range of Haskellers. If you're still a beginner, you will benefit tremendously from learning all the ins and outs and Haskell's structures and the large amount of hands-on practice. If you're at more of an intermediate level, you may find some of the early content easy, but you'll still likely benefit from relearning some of the key concepts in a more formal way. You will also probably learn many important implementation details of other data structures that you didn't know before. Plus, many of the exercise problems will challenge even experienced Haskllers, so you're sure to get some good practice in!

Just note that this course does not teach about toolchain setup or basic Haskell syntax. To learn about those topics, take a look at Setup.hs (which is free) and Haskell From Scratch, respectively.

How Much Content does this Course Provide?

The first part of this course features almost 4 hours of video lecture content. In the exercises, there are about 120 practice problems. You'll also implement 3 data structures from scratch, which comes to around an extra 60 problems. When I do a GitHub comparison of my own "answers" branch to the "starter" branch, the diff adds about 2500 lines of code, second only to Practical Haskell among our different courses. So the amount of practice available is quite substantial.

How are Course Materials Delivered?

Video lectures are viewable through the course portal. Each module also has a downloadable PDF with the lecture slides so you can follow along more easily. For each module, you'll also find a PDF document explaining the instructions for each set of exercises. These are downloadable from the first lecture in each module.

Then for the exercises, you will download a .zip file from the first lecture page of the course containing a buildable Haskell project. You'll be able to write your code within this project, and run test commands to ensure your answers for each set of exercises are correct.

How Long Can I Access Course Material?

Purchasing this course grants lifetime access to the material. If you don't have time to go through it now, you can always come back to it later!

What if I get Stuck on Something?

You'll be able to email the instructor for help. In the last lecture of each module, you'll also be able to download a separate .zip file that has all the answers for the exercise problems.

What if I Don't Like the Course?

This course comes with a 14-day refund guarantee. If you don't like the course, you can get a full refund within 14 days, no questions asked.

If you have any more questions, you can email james@mondaymorninghaskell.me! Head to the course page if you're ready to buy!