Zero to Haskell: Pre-Plutus Program

[IMPACT] Please describe your proposed solution.

Zero to Haskell is a 10 week program that covers all of the foundational knowledge of Haskell required for students to successfully complete the Plutus Pioneer Program. Through discussions with the IOG Plutus Pioneer team, we developed coursework for novices covering the important fundamentals of Haskell.

Our Catalyst proposal is to fund 20 scholarships for the Zero to Haskell program.

It has a project oriented approach culminating in the building of 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 address 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 the fundamentals of Haskell, but to give students the absolute best chance at learning Plutus and ultimately finding a career within the Cardano ecosystem.

[IMPACT] Please describe how your proposed solution will address the Challenge that you have submitted it in.

The Zero to Haskell program is designed by someone who learned Haskell as their first programming language for novice programmers who lack a background in programming. This foundational knowledge in Haskell is imperative for successfully learning Plutus.

Saurabh Nanda’s talk about this topic is a great resource to understand the difficulties Haskell learners face compared with learning other programming languages. On a technical level, the argument goes like the following:

1. Haskell makes a hard commitment on keeping code pure (unlike mainstream PLs)
2. This forces the programmer to explicit annotate at the type level whether a function is pure or not
3. This leads to abstractions like functors and monads to become crucial to write meaningful Haskell code
4. These abstractions are implemented as Type Classes with Higher Kinded Polymorphism. 
5. This level of polymorphism is uncommon in mainstream languages. Also, learning abstraction is always more difficult than learning concrete examples. 
6. plus a plethora of oddities like curryfication, partial application, weird operators, etc…

The above can be summarized in ordinary words as follows:

Whereas other languages encourage you to separate pure code from impure code, Haskell forces you to do so. Whereas other languages encourage you to rely on abstractions (normally, via SOLID principles), Haskell pushes you straight into abstractions to write anything useful. 

Of course, this leads to a steep learning curve. In most programming languages you start by writing small programs not caring about abstractions or design patterns. As experience is gained, you start to use better interfaces, applying SOLID principles and patterns like Factories, Decorators, dependency injections, etc… In Haskell, you are pretty much forced to jump directly from toy programs to high level abstractions.

So, How do we deal with this jump? We follow an individual mentoring approach as opposed to MOOC based courses. We believe this is a better learning solution because, as stated before, the main problem with Haskell is its high levels of abstraction. Learning abstractions is a difficult task which becomes an order of magnitude more difficult if you are on your own. 

There are tons of good resources freely available to learn Haskell on the web, but people still struggle with it. We think they are lacking a companion who can clear out the misconceptions and focus on the key concepts, boosting up the process of acquiring the right mindset. This is only possible if you have access to someone tracking your progress and willing to help you on a 1:1 basis.

We provide students exercises based on the book “Piensa en Haskell” (Translation WIP), which is the book used at University of Sevilla for its Haskell course. This material is written such that no prior experience in any programming language is needed. So we think it is a good choice for our students.

The course’s project is the snake game which is written first using no abstractions at all (except for mandatory IO monad which is given to the student) and then refactor it to introduce monads step by step. This smooths out Haskell’s learning curve, because at first, you are inline with Haskell’s hard commitment to purity. All the abstractions are later introduced step by step on the code with a justification on its necessity and with clarity about the benefits they provide.

[IMPACT] What are the main risks that could prevent you from delivering the project successfully and please explain how you will mitigate each risk?

The biggest risk we face in our program is the feasibility of a novice programmer learning the fundamentals of Haskell and being able to apply them while learning Plutus. Being a mathematician, Luis understood mathematical concepts central to certain subjects of Haskell which may have given him a competitive edge compared to someone who does not have a mathematics background. Fortunately, the solution to this problem lies with the teacher of the course, who is well versed in the mathematical concepts underlying the topics covered in the course and will be able to spend ample time with students 1:1 in order to teach them any basic mathematics knowledge they are lacking.

Students not attending the course is a major risk. We will call and email any students that start to miss the in-person classes or are not active in the Discord channel.

Students that attend the class but not putting in the effort for assignments is another risk. This risk can be mitigated by tracking student activity on course work and conducting regular 1:1 check-ins.

[FEASIBILITY] Please provide a detailed plan, including timeline and key milestones for delivering your proposal.

June 30 - Github project preparation

June 30 - Translation .25 (first quarter of coursework translated to English)

July 30 - Translation 0.5 (first half of coursework translated to English)

August 30 - Scholarship application available

September 15 - All coursework material completed

September 31 - Scholarships awarded

October 17 - Start of course

December 22 - In-class course completion

January 22, 2023 - Course completed

February 6-10, 2023 - NFT certificate of completion issues

Feb 6-10, 2023 - 1:1 session with students to help prepare for Plutus Pioneer Program

[FEASIBILITY] Please provide a detailed budget breakdown.

Budget:

1 Scholarships @ $2500/each w/ 10% discount = $2,250

20 scholarships offered = total $45,000

• Teaching fees: $15000
• Marketing: $10000
• Curriculum Development: $4500
• Website: $3500
• Video & Audio: $2000
• Social media: $3500
• Curriculum & Textbook Translation: $2000
• Post Class Analysis and Student Success Tracking: $4500

Total = $45000

[FEASIBILITY] Please provide details of the people who will work on the project.

Luis Morillo-Najarro is a mathematics graduate from University of Sevilla in 2014. He learned Haskell as his first programming language in 2009 and is a 2021 graduate of the Plutus Pioneer Program. Luis is the designer of the course work and the teacher of the class.

Patrick Lance is a business and information systems graduate from Ohio University in 2009. He has been studying real world use-cases for blockchain since 2017. He has worked in the past on studies for blockchain in supply chain and has tokenized commercial real estate. Patrick is in charge of marketing, website design/content, initial scholarship application review, minting NFT certifications of completion, and will conduct regular follow up with students to track progress in Plutus Pioneer and work search assistance.

[FEASIBILITY] If you are funded, will you return to Catalyst in a later round for further funding? Please explain why / why not.

Yes, we plan on providing scholarships to twenty students each quarter.

[FEASIBILITY] Are you or any member of your team working on any other proposals in this Fund9?

[FEASIBILITY] Are you or your team working on any other proposals from previous Funds?

[AUDITABILITY] Please describe what you will measure to track your project's progress, and how will you measure these?

Metrics to track:

1. Class percent fill rate - how many of the openings did we fill
2. Class participation rate - how many students join for the two live sessions each week
3. Out of class participation rate - how many students engage with the Discord community / reach out to the course teacher via email
4. Completion rate - how many students complete the course and receive their NFT certification
5. Plutus Pioneer acceptance rate - how many students apply and are accepted to the Plutus Pioneer Program
6. Plutus Pioneer graduation rate - how many of our students go on to complete the Plutus Pioneer Program
7. Job placement rate - how many students find work in the Cardano ecosystem once they complete the Plutus Pioneer Program

[AUDITABILITY] What does success for this project look like?

Success will be measured in two ways:

1.   Student progress will be tracked during the course and successful completion of the course will culminate in the building of the snake game using Haskell
2.   Students will then be encouraged and assisted in applying to the Plutus Pioneer Program where we will continue to work with them to track their progress – with ultimate success being graduation from the Plutus Pioneer Program

For students that successfully complete the Zero to Haskell program and the Plutus Pioneer Program, we will assist them in job placement.

[AUDITABILITY] Please provide information on whether this proposal is a continuation of a previously funded project in Catalyst or an entirely new one.

Entirely new proposal.