Open Site Navigation

*The next course is scheduled to start October 17, 2022.

Introduction

The Zero to Haskell bootcamp program aims to teach Haskell programming language to any kind of student, whether they have prior programming experience or not. The course is designed to cover all the topics to become productive writing Haskell, with special focus on the knowledge needed to use the Plutus API: The Haskell based smart contract interface for the Cardano Blockchain.

Methodology

Haskell is notoriously known for being a difficult language to learn. While there are strong arguments for that claim, our course is  designed to make learning Haskell easier than ever before. The reason many people fail to learn Haskell by themselves is because Haskell requires a different way of thinking and relies on uncommon abstractions not seen in other programming languages.

This is why we follow a mentor-student methodology with small groups, hence students have live access (via discord and live coding sessions) to a mentor who will be answering their questions and following their progress as the course progresses. We think this approach overcomes most of the common pitfalls self-learners face when they try to learn Haskell such as outdated learning material, lack of guidance about "what works best", etc... But most importantly: having someone giving you advice constantly on how to [read, write and think about code. 

https://www.poberezkin.com/posts/2021-04-21-what-i-wish-somebody-told-me-when-i-was-learning-Haskell.html

# Course Overview

The course is design to last 10 weeks. It has a project oriented approach consisting in building the snake game in Haskell. Also, a workbook will be provided to extend student knowledge.

One of the key features of the project is that it is written twice. The first time, students will be writing the snake game using pure functions only. Then, they will refactor the code to use more common abstractions like Monads and `mtl`-style. With this double-writing methodology, we try to attend a common problem faced when learning monads: "Why should I use them?" Students will see the advantages of using abstractions and how they lead to more readable code.

The course is planned as follows, and can be adapted depending on students' learning speed:

**Week 1**
- Haskell Tooling
- Writing basic functions
- List comprehension
- Project Introduction

**Week 2**
- Record Types and Algebraic Data Types
- Pattern matching
- List Recursion
- Project Build the Board: using standard libraries like `array`

**Week 3**
- Currying and partial application
- Higher order functions.
- Factor out recursion with `fmap`, `fold`, etc...
- Project Build the Snake: using standard libraries like `containers`

**Week 4**
- Type classes
- Random value generation
- Introduction to functors
- Project Build the Logic of the Game: Generate a board with random initial values using `random` library. Minimal Viable Product

**Week 5**
- More about Functors
- Introduction to Monads: `Maybe` and `List`
- Project Refactor 1: Convert the MVP into a fully feature snake game

**Week 6**
- Monads: `State` and `Reader`.
- do notation
- Project Refactor 2: Use the state monad to write the game logic.

**Week 7**
- Monads: `IO` and `async` package for asynchronous programming.
- Introduction Transformers: StateT and ReaderT.
- Project Refactor 3: Write the application using a transformer stack.

**Week 8**
- Transformers: introduction to `mtl` library.
- Project Refactor 4: Write the application leaning on `mtl` abstractions.

**Week 9**
- Note on other design patterns like `RIO`, or effect systems
- Project Finishing the Game: with `mtl` abstraction.

**Week 10**
- Brief introduction to template Haskell
- Brief introduction to Plutus API
- Project (Optional) : Use the abstracted version of the software to easily change frontend keeping the backend the same. For example, using `brick` or `sdl` libraries

After the class ends, each student will have a 1:1 session to help them prepare their application to the Plutus Pioneer Program. Our goal is not just to teach you the fundamentals of Haskell, but to give you the absolute best chance at learning Plutus and ultimately finding a career within the Cardano ecosystem.

Menu

Social

Discord

Github

YouTube

Haskell is the basis for the smart contract language on Cardano, Plutus. Understanding the fundamentals of Haskell is critical for learning  Plutus. Go Zero to Haskell today and get your career in Cardano started!

Learn online today!

© 2022 by Zero to Haskell.