Hoon School

Table of Contents

• Introduction

Lessons

1. Hoon Syntax - This module will discuss the fundamental data concepts of Hoon and how programs effect control flow.
2. Azimuth (Urbit ID) - This module introduces how Urbit ID is structured and provides practice in converting and working with @p identity points. (Optional)
3. Gates (Functions) - This module will teach you how to produce deferred computations for later use, like functions in other languages.
4. Molds (Types) - This module will introduce the Hoon type system and illustrate how type checking and type inference work.
5. Cores - This module will introduce the key Hoon data structure known as the core, as well as ramifications.
6. Trees and Addressing - This module will elaborate how we can use the structure of nouns to locate data and evaluate code in a given expression. It will also discuss the important list mold builder and a number of standard library operations.
7. Libraries - This module will discuss how libraries can be produced, imported, and used.
8. Testing Code - This module will discuss how we can have confidence that a program does what it claims to do, using unit testing and debugging strategies. (Optional)
9. Text Processing I - This module will discuss how text is represented in Hoon, discuss tools for producing and manipulating text, and introduce the %say generator, a new generator type.
10. Cores & Doors - This module will start by introducing the concept of gate-building gates; then it will expand our notion of cores to include doors; finally it will introduce a common door, the ++map, to illustrate how doors work.
11. Data Structures - This module will introduce you to several useful data structures built on the door, then discuss how the compiler handles types and the sample.
12. Type Checking - This module will cover how the Hoon compiler infers type, as well as various cases in which a type check is performed.
13. Conditional Logic - This module will cover the nature of loobean logic and the rest of the ? wut runes.
14. Subject-Oriented Programming - This module discusses how Urbit's subject-oriented programming paradigm structures how cores and values are used and maintain state, as well as how deferred computations and remote value lookups (“scrying”) are handled.
15. Text Processing II - This module will elaborate on text representation in Hoon, including formatted text, and %ask generators. (Optional)
16. Functional Programming - This module will discuss some gates-that-work-on-gates and other assorted operators that are commonly recognized as functional programming tools.
17. Text Processing III - This module will cover text parsing. (Optional)
18. Generic and Variant Cores - This module introduces how cores can be extended for different behavioral patterns. (Optional)
19. Mathematics - This module introduces how non-@ud mathematics are instrumented in Hoon. (Optional)