Urbit Developers
  • Lightning Tutorials

  • Build a Chat App
    • Core Curriculum

    • Environment Setup
      • Hoon School

        • Introduction
        • 1. Hoon Syntax
        • 2. Azimuth (Urbit ID)
        • 3. Gates (Functions)
        • 4. Molds (Types)
        • 5. Cores
        • 6. Trees and Addressing
        • 7. Libraries
        • 8. Testing Code
        • 9. Text Processing I
        • 10. Cores and Doors
        • 11. Data Structures
        • 12. Type Checking
        • 13. Conditional Logic
        • 14. Subject-Oriented Programming
        • 15. Text Processing II
        • 16. Functional Programming
        • 17. Generic and Variant Cores
        • 18. Mathematics
        • App School I

          • Introduction
          • 1. Arvo
          • 2. The Agent Core
          • 3. Imports and Aliases
          • 4. Lifecycle
          • 5. Cards
          • 6. Pokes
          • 7. Structures and Marks
          • 8. Subscriptions
          • 9. Vanes
          • 10. Scries
          • 11. Failure
          • 12. Next Steps
          • Appendix: Types
          • App School II (Full-Stack)

            • Introduction
            • 1. Types
            • 2. Agent
            • 3. JSON
            • 4. Marks
            • 5. Eyre
            • 6. React app setup
            • 7. React app logic
            • 8. Desk and glob
            • 9. Summary
          • Additional Guides

          • Writing Aqua Tests
          • CLI Apps
          • Using the HTTP API
          • Working with JSON
          • Parsing
          • Sail: HTML in Hoon
          • Distributing Software
          • Working with Strings
          • Writing Unit Tests
            Urbit
            • Lightning Tutorials

            • Build a Chat App
              • Core Curriculum

              • Environment Setup
                • Hoon School

                  • Introduction
                  • 1. Hoon Syntax
                  • 2. Azimuth (Urbit ID)
                  • 3. Gates (Functions)
                  • 4. Molds (Types)
                  • 5. Cores
                  • 6. Trees and Addressing
                  • 7. Libraries
                  • 8. Testing Code
                  • 9. Text Processing I
                  • 10. Cores and Doors
                  • 11. Data Structures
                  • 12. Type Checking
                  • 13. Conditional Logic
                  • 14. Subject-Oriented Programming
                  • 15. Text Processing II
                  • 16. Functional Programming
                  • 17. Generic and Variant Cores
                  • 18. Mathematics
                  • App School I

                    • Introduction
                    • 1. Arvo
                    • 2. The Agent Core
                    • 3. Imports and Aliases
                    • 4. Lifecycle
                    • 5. Cards
                    • 6. Pokes
                    • 7. Structures and Marks
                    • 8. Subscriptions
                    • 9. Vanes
                    • 10. Scries
                    • 11. Failure
                    • 12. Next Steps
                    • Appendix: Types
                    • App School II (Full-Stack)

                      • Introduction
                      • 1. Types
                      • 2. Agent
                      • 3. JSON
                      • 4. Marks
                      • 5. Eyre
                      • 6. React app setup
                      • 7. React app logic
                      • 8. Desk and glob
                      • 9. Summary
                    • Additional Guides

                    • Writing Aqua Tests
                    • CLI Apps
                    • Using the HTTP API
                    • Working with JSON
                    • Parsing
                    • Sail: HTML in Hoon
                    • Distributing Software
                    • Working with Strings
                    • Writing Unit Tests
                      Guides/Core Curriculum

                      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.
                      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.
                      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.
                      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. It will also cover text parsing.
                      17. Generic and Variant Cores - This module introduces how cores can be extended for different behavioral patterns.
                      18. Mathematics - This module introduces how non-@ud mathematics are instrumented in Hoon.
                      Edit this page on GitHub