curriculum-processor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "40c2d95b",
   "metadata": {},
   "source": [
    "# Visualizing Objectives\n",
    "\n",
    "\n",
    "\n",
    "Principles:\n",
    "\n",
    "1. Objective chains are directed and acyclic.\n",
    "\n",
    "2. Each node represents a discrete competency cluster.\n",
    "\n",
    "3. Each edge represents a dependency of one competency cluster on another.\n",
    "\n",
    "4. Competency clusters should be as coherent as possible.\n",
    "\n",
    "2. Edge chains should be independent.  I.e. one should not link to more than one previous node in a chain.  (One may link to both nodes in a forked chain.)\n",
    "    \n",
    "    For instance, if 303 depends on 170 and 190, but 190 depends on 170, then only 190 should be linked to 303.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "937396ec",
   "metadata": {},
   "source": [
    "##  Produce CSV from node files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dd91586b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lessons/100.yml\n",
      "/home/neal/urbit/curriculum/lessons/100.yml\n",
      "{'uuid': 100, 'layout': 'node', 'title': 'Administer an Urbit ship manuaully.', 'tags': ['%sysadmin'], 'prerequisites': ['0'], 'postrequisites': ['110'], 'objectives': ['Explain what an Urbit ship is.', 'Identify the `.urb/` directory.', 'Distinguish a fakeship from a liveship.', \"Use the `+ls` generator to show a directory's contents.\", '`|mount` and `|commit` a desk.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/101.yml\n",
      "/home/neal/urbit/curriculum/lessons/101.yml\n",
      "lessons/102.yml\n",
      "/home/neal/urbit/curriculum/lessons/102.yml\n",
      "{'uuid': 102, 'layout': 'node', 'title': 'Description of address space structure.', 'tags': ['%azimuth'], 'prerequisites': ['0'], 'postrequisites': ['112', '302'], 'objectives': ['Understand the role of the public-key infrastructure in Urbit.', 'Describe the high-level architecture of the Urbit ID address space and distinguish types of points.', 'Interpret and apply the Azimuth point naming scheme.', 'Identify point features such as activity.', 'List at least two services/roles provided by a galaxy for the network.', 'List at least two services provided by a star for its planets.'], 'runes': [''], 'irregular': [''], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/103.yml\n",
      "/home/neal/urbit/curriculum/lessons/103.yml\n",
      "{'uuid': 103, 'layout': 'node', 'title': 'Aural Hoon', 'tags': ['%hoon'], 'prerequisites': ['0'], 'postrequisites': [], 'objectives': ['Pronounce ASCII characters per standard Hoon developer practice.'], 'runes': [''], 'irregular': [''], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/110.yml\n",
      "/home/neal/urbit/curriculum/lessons/110.yml\n",
      "{'uuid': 110, 'layout': 'node', 'title': 'Syntax, nouns, auras', 'tags': ['%hoon'], 'prerequisites': ['100', '103'], 'postrequisites': ['112', '113'], 'objectives': ['Distinguish nouns, cells, and atoms.', 'Apply auras to transform an atom.', 'Identify common Hoon molds, such as cells, lists, and tapes.', 'Annotate Hoon code with comments.'], 'runes': ['::'], 'irregular': ['@', '[]', '~[]', \"''\", '\"\"'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/112.yml\n",
      "/home/neal/urbit/curriculum/lessons/112.yml\n",
      "{'uuid': 112, 'layout': 'node', 'title': 'Exploration of address space structure.', 'tags': ['%azimuth'], 'prerequisites': ['102', '110'], 'postrequisites': ['240'], 'objectives': ['Use Hoon to map the Azimuth address space domains and boundaries.', 'Identify points, sponsors, neighbors, etc. from `@p` identifiers and simple operations.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/113.yml\n",
      "/home/neal/urbit/curriculum/lessons/113.yml\n",
      "{'uuid': 113, 'layout': 'node', 'title': 'Naked generator design, syncing, etc., control structures', 'tags': ['%hoon'], 'prerequisites': ['110'], 'postrequisites': ['115', '195'], 'objectives': ['Pin a face to the subject.', 'Make a decision at a branch point.', 'Distinguish loobean from boolean operations.', 'Slam a gate (call a function).', 'Produce a generator to convert a value between auras.'], 'runes': ['%-', '=/', '?:', '^-', '~&'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '\"\"\\n\"<!-- (implied `|=` for later discussion) -->\"\\n', 'content': ''}\n",
      "lessons/115.yml\n",
      "/home/neal/urbit/curriculum/lessons/115.yml\n",
      "{'uuid': 115, 'layout': 'node', 'title': 'Irregular forms, sugar syntax', 'tags': ['%hoon'], 'prerequisites': ['113'], 'postrequisites': ['120', '175', '201', '215', '250'], 'objectives': ['Identify current known irregular syntax.', 'Convert between regular and irregular forms of runes to date.'], 'runes': [], 'irregular': ['()'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/120.yml\n",
      "/home/neal/urbit/curriculum/lessons/120.yml\n",
      "{'uuid': 120, 'layout': 'node', 'title': 'Basic dry gates', 'tags': ['%hoon'], 'prerequisites': ['115'], 'postrequisites': ['125'], 'objectives': ['Employ a gate to defer a computation.', 'Produce a gate as a generator.'], 'runes': ['|=', '!!'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/125.yml\n",
      "/home/neal/urbit/curriculum/lessons/125.yml\n",
      "{'uuid': 125, 'layout': 'node', 'title': 'Molds, typechecking', 'tags': ['%hoon'], 'prerequisites': ['120'], 'postrequisites': ['130', '160'], 'objectives': ['Identify a mold in the hierarchy of Urbit types (nouns, molds, marks).', 'Understand how type inference and type checking takes place.', 'Bunt a mold.', 'Produce a type union.', 'Produce a named tuple.', 'Identify type using `!>`.'], 'runes': ['^+', '$?', '$_', '$:', '^*', '!>'], 'irregular': ['*'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/130.yml\n",
      "/home/neal/urbit/curriculum/lessons/130.yml\n",
      "{'uuid': 130, 'layout': 'node', 'title': 'Traps, recursion', 'tags': ['%hoon'], 'prerequisites': ['125'], 'postrequisites': ['133'], 'objectives': ['Employ a trap to produce a reentrant block of code.', 'Produce a recursive gate.', 'Distinguish head and tail recursion.'], 'runes': ['|-', '.+', '%='], 'irregular': ['+()', '$()'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/133.yml\n",
      "/home/neal/urbit/curriculum/lessons/133.yml\n",
      "{'uuid': 133, 'layout': 'node', 'title': 'Basic cores, arms', 'tags': ['%hoon'], 'prerequisites': ['130'], 'postrequisites': ['135', '156'], 'objectives': ['Consider Hoon structures as cores.', 'Identify the special role of the `$` buc arm in many cores.', 'Order neighboring cores within the subject for addressibility.'], 'runes': ['|%', '++', '+$', '=<', '=>'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/135.yml\n",
      "/home/neal/urbit/curriculum/lessons/135.yml\n",
      "{'uuid': 135, 'layout': 'node', 'title': 'Addressing, trees', 'tags': ['%hoon'], 'prerequisites': ['133'], 'postrequisites': ['140', '170'], 'objectives': ['Address nodes in a tree using numeric notation.', 'Address nodes in a tree using lark notation.', 'Address data in a tree using faces.', 'Distinguish `.` and `:` notation.', 'Diagram Hoon structures such as gates into the corresponding abstract syntax tree.'], 'runes': ['=+'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/140.yml\n",
      "/home/neal/urbit/curriculum/lessons/140.yml\n",
      "{'uuid': 140, 'layout': 'node', 'title': 'Lists, trees', 'tags': ['%stdlib'], 'prerequisites': ['135'], 'postrequisites': ['145'], 'objectives': ['Use lists to organize data.', 'Convert between kinds of lists (e.g. tapes).', 'Diagram lists as binary trees.', 'Operate on list elements using `snag`, `find`, `weld`, etc.'], 'runes': [], 'irregular': ['~[]'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/145.yml\n",
      "/home/neal/urbit/curriculum/lessons/145.yml\n",
      "{'uuid': 145, 'layout': 'node', 'title': 'Libraries', 'tags': ['%hoon'], 'prerequisites': ['140'], 'postrequisites': ['150', '163'], 'objectives': ['Import a library using `/+` faslus.', 'Create a new library in `/lib`.'], 'runes': ['/+'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/150.yml\n",
      "/home/neal/urbit/curriculum/lessons/150.yml\n",
      "{'uuid': 150, 'layout': 'node', 'title': 'Doors', 'tags': ['%hoon'], 'prerequisites': ['145'], 'postrequisites': ['155', '183'], 'objectives': ['Identify the structure of a door and relate it to a core.', 'Pull an arm in a door.'], 'runes': ['|_', '%~'], 'irregular': ['~()'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/153.yml\n",
      "/home/neal/urbit/curriculum/lessons/153.yml\n",
      "{'uuid': 153, 'layout': 'node', 'title': 'The beak', 'tags': ['%hoon'], 'prerequisites': ['145'], 'postrequisites': ['155'], 'objectives': ['Identify the role of a desk in the Clay filesystem.', 'Identify the components of a beak.', 'Identify filesystem locations (including desks).', 'Identify the components of a path.'], 'runes': [], 'irregular': ['%', '/==='], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/155.yml\n",
      "/home/neal/urbit/curriculum/lessons/155.yml\n",
      "{'uuid': 155, 'layout': 'node', 'title': 'Revisiting Cores', 'tags': ['%hoon'], 'prerequisites': ['150'], 'postrequisites': ['165'], 'objectives': ['Build cores for later use and with custom samples.', 'Identify the `$` buc arm in several structures and its role.'], 'runes': ['|.', '|:'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/156.yml\n",
      "/home/neal/urbit/curriculum/lessons/156.yml\n",
      "{'uuid': 156, 'layout': 'node', 'title': 'Typechecking', 'tags': ['%hoon'], 'prerequisites': ['133'], 'postrequisites': ['184'], 'objectives': ['Use assertions to enforce type constraints.', 'Identify a `lest` (as opposed to a list).', 'Produce a type arm.'], 'runes': ['?>', '?<', '?~', '+$'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/160.yml\n",
      "/home/neal/urbit/curriculum/lessons/160.yml\n",
      "{'uuid': 160, 'layout': 'node', 'title': 'Basic text transformations', 'tags': ['%stdlib'], 'prerequisites': ['125'], 'postrequisites': ['185'], 'objectives': ['Review Unicode text structure.', 'Distinguish cords and tapes and their characteristics.', 'Transform and manipulate text using text conversion arms: - `++crip`: convert `tape` to `cord` (`tape`→`cord`) - `++trip`: convert `cord` to `tape` (`cord`→`tape`) - `++cass`: convert upper-case text to lower-case (`tape`→`tape`) - `++cuss`: convert lower-case text to upper-case (`tape`→`tape`) - [`++scot`](https://urbit.org/docs/reference/library/4m/#scot): render `dime` as `cord` (`dime`→`cord`) - [`++scow`](https://urbit.org/docs/reference/library/4m/#scow): render `dime` as `tape` (`dime`→`tape`)', 'Interpolate text.', 'Employ sigpam logging levels.'], 'runes': ['~&  >>>'], 'irregular': ['\"{<>}\"'], 'key_points': [], 'assessments': [], 'comments': '\"\"\\n\"<!-- 4b, 4m -->\"\\n\"<!-- #wishlist better lib on top of primitives for parsing at about this level -->\"\\n', 'content': ''}\n",
      "lessons/163.yml\n",
      "/home/neal/urbit/curriculum/lessons/163.yml\n",
      "{'uuid': 163, 'layout': 'node', 'title': 'Producing textually rich %say generators.', 'tags': ['%hoon'], 'prerequisites': ['145'], 'postrequisites': ['234', '263'], 'objectives': ['Create a `%say` generator.', 'Identify how Dojo sees and interprets a generator as a cell with a head tag.', 'Identify the elements of a `sample` for a `%say` generator.', 'Produce a `%say` generator with optional arguments.'], 'runes': [':-'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/165.yml\n",
      "/home/neal/urbit/curriculum/lessons/165.yml\n",
      "{'uuid': 165, 'layout': 'node', 'title': 'Subject-oriented programming', 'tags': ['%hoon'], 'prerequisites': ['155'], 'postrequisites': ['180'], 'objectives': ['Review subject-oriented programming as a design paradigm.', 'Explain how Hoon manages the subject and wing search paths.', 'Explain how to skip to particular matches in a wing search path through the subject.', 'Identify common Hoon patterns: batteries, and doors, arms, wings, and legs.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/170.yml\n",
      "/home/neal/urbit/curriculum/lessons/170.yml\n",
      "{'uuid': 170, 'layout': 'node', 'title': 'Basic debugging techniques', 'tags': ['%testing'], 'prerequisites': ['135'], 'postrequisites': ['185', '190'], 'objectives': ['Distinguish errors, faults, and failures.', 'Distinguish latent, masked, and manifest errors.', 'Enumerate and identify common error messages.', 'Employ a debugging strategy to identify and correct errors in Hoon code.'], 'runes': ['!:', '!.'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/175.yml\n",
      "/home/neal/urbit/curriculum/lessons/175.yml\n",
      "{'uuid': 175, 'layout': 'node', 'title': 'Building code', 'tags': ['%hoon'], 'prerequisites': ['115'], 'postrequisites': ['180'], 'objectives': ['Build code samples with `-build-file` thread.', 'Discuss Ford import runes.'], 'runes': ['/-', '/*', '/='], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/180.yml\n",
      "/home/neal/urbit/curriculum/lessons/180.yml\n",
      "{'uuid': 180, 'layout': 'node', 'title': 'State: tisket etc.', 'tags': ['%hoon'], 'prerequisites': ['165', '175'], 'postrequisites': ['255', '260', '265', '270', '275', '280', '282', '283', '284', '285', '288', '290', '295'], 'objectives': ['Discuss stateful v. stateless applications and path dependence.', \"Enumerate Hoon's tools for dealing with state:  `=.` tisdot, `=^` tisket, `;<` micgal, `;~` micsig.\", 'Defer a computation.'], 'runes': ['=.', '=^', '=~', ';<', ';~'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/183.yml\n",
      "/home/neal/urbit/curriculum/lessons/183.yml\n",
      "{'uuid': 183, 'layout': 'node', 'title': 'Sets, maps, jars, jugs', 'tags': ['%hoon'], 'prerequisites': ['150'], 'postrequisites': ['233', '263', '283', '284', '333'], 'objectives': ['Identify units, sets, maps, and compound structures like jars and jugs.', 'Explain why units and vases are necessary.', 'Use helper arms and syntax:  `` ` ``, `biff`, `some`, etc.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '\"<!-- 2a -->\"\\n', 'content': ''}\n",
      "lessons/184.yml\n",
      "/home/neal/urbit/curriculum/lessons/184.yml\n",
      "{'uuid': 184, 'layout': 'node', 'title': 'Loobean operations', 'tags': ['%hoon'], 'prerequisites': ['156'], 'postrequisites': ['233'], 'objectives': ['Produce loobean expressions.', 'Reorder conditional arms.', 'Switch against a union with or without default.'], 'runes': ['?|', '?&', '?!', '?.', '?-', '?+'], 'irregular': ['&', '|', '!'], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/185.yml\n",
      "/home/neal/urbit/curriculum/lessons/185.yml\n",
      "{'uuid': 185, 'layout': 'node', 'title': 'I/O: Tanks, tangs, wains, wangs, and whangdoodles', 'tags': ['%stdlib'], 'prerequisites': ['160', '170'], 'postrequisites': ['303'], 'objectives': ['Identify tanks, tangs, wains, walls, and similar formatted printing data structures.', 'Interpret logging message structures (`%leaf`, `$rose`, `$palm`).', 'Interpolate to tanks with `><` syntax.', 'Produce useful error annotations using `~|` sigbar.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/188.yml\n",
      "/home/neal/urbit/curriculum/lessons/188.yml\n",
      "{'uuid': 188, 'layout': 'node', 'title': 'Producing interactive %ask generators.', 'tags': ['%hoon'], 'prerequisites': ['163', '185'], 'postrequisites': [], 'objectives': ['Create an `%ask` generator.', 'Produce basic formatted `%sole` effects from a generator.'], 'runes': [':-'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/190.yml\n",
      "/home/neal/urbit/curriculum/lessons/190.yml\n",
      "{'uuid': 190, 'layout': 'node', 'title': 'Unit tests with -test thread.', 'tags': ['%testing'], 'prerequisites': ['170'], 'postrequisites': ['303', '390'], 'objectives': ['Run existing unit tests.', 'Produce a unit test.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/192.yml\n",
      "/home/neal/urbit/curriculum/lessons/192.yml\n",
      "{'uuid': 192, 'layout': 'node', 'title': 'Distribution of desks without dockets.', 'tags': ['%clay'], 'prerequisites': ['190'], 'postrequisites': ['217'], 'objectives': ['Produce a desk using `|merge`.', 'Mark a desk public (without a docket file).'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/195.yml\n",
      "/home/neal/urbit/curriculum/lessons/195.yml\n",
      "{'uuid': 195, 'layout': 'node', 'title': 'Nature of jammed nouns.', 'tags': ['%hoon'], 'prerequisites': ['113'], 'postrequisites': ['301'], 'objectives': ['Discuss the role jammed nouns play in Urbit.', 'Jam a noun with `jam`.', 'Unjam a noun with `cue`.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/200.yml\n",
      "/home/neal/urbit/curriculum/lessons/200.yml\n",
      "{'uuid': 200, 'layout': 'node', 'title': 'State machine/event log', 'tags': ['%arvo'], 'prerequisites': ['0'], 'postrequisites': ['201', '300', '301'], 'objectives': ['Explain Arvo as a state machine and event log.', 'Explain Kelvin versioning and identify the system components that require this approach.'], 'runes': ['/?', '!?'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/201.yml\n",
      "/home/neal/urbit/curriculum/lessons/201.yml\n",
      "{'uuid': 201, 'layout': 'node', 'title': 'Moves', 'tags': ['%arvo'], 'prerequisites': ['115', '200'], 'postrequisites': ['205', '210', '215', '220', '225', '230', '235', '240', '245'], 'objectives': ['Enumerate basic move types and their relationship to caller and callee.', 'Examine a programmatic `$move` and identify its components.'], 'runes': ['.^'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/202.yml\n",
      "/home/neal/urbit/curriculum/lessons/202.yml\n",
      "lessons/205.yml\n",
      "/home/neal/urbit/curriculum/lessons/205.yml\n",
      "{'uuid': 205, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%ames'], 'prerequisites': ['201'], 'postrequisites': ['255'], 'objectives': ['Explain the services Ames provides to the system.', 'Diagram the architecture of Ames as a network.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/210.yml\n",
      "/home/neal/urbit/curriculum/lessons/210.yml\n",
      "{'uuid': 210, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%behn'], 'prerequisites': ['201'], 'postrequisites': ['260'], 'objectives': ['Explain the services Behn provides to the system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/215.yml\n",
      "/home/neal/urbit/curriculum/lessons/215.yml\n",
      "{'uuid': 215, 'layout': 'node', 'title': 'Heuristic description of vane; use of marks to convert data.', 'tags': ['%clay'], 'prerequisites': ['201', '115'], 'postrequisites': ['265'], 'objectives': ['Explain the services Clay provides to the system.', 'Identify key Clay artifacts:  desks, marks, etc.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/217.yml\n",
      "/home/neal/urbit/curriculum/lessons/217.yml\n",
      "{'uuid': 217, 'layout': 'node', 'title': 'Distribution of software using Grid.', 'tags': ['%clay'], 'prerequisites': ['192', '215'], 'postrequisites': ['382', '390'], 'objectives': ['Produce a desk suitable for distribution (with a docket file).', 'Install and distribute software.', 'Explain elements of a docket file.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/220.yml\n",
      "/home/neal/urbit/curriculum/lessons/220.yml\n",
      "{'uuid': 220, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%dill'], 'prerequisites': ['201'], 'postrequisites': ['270'], 'objectives': ['Explain the services Dill provides to the system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/222.yml\n",
      "/home/neal/urbit/curriculum/lessons/222.yml\n",
      "{'uuid': 184, 'layout': 'node', 'title': 'Molds and mold builders', 'tags': ['%hoon'], 'prerequisites': ['150'], 'postrequisites': ['255', '260', '265', '270', '275', '280', '285', '290', '295', '299'], 'objectives': ['Produce mold builder arms.', 'Convert arbitrary nouns between molds using `;;` micmic.'], 'runes': ['|$', ';;'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/225.yml\n",
      "/home/neal/urbit/curriculum/lessons/225.yml\n",
      "{'uuid': 225, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%eyre'], 'prerequisites': ['201'], 'postrequisites': ['275', '285', '330'], 'objectives': ['Explain the services Eyre provides to the system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/230.yml\n",
      "/home/neal/urbit/curriculum/lessons/230.yml\n",
      "{'uuid': 230, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%gall'], 'prerequisites': ['201'], 'postrequisites': ['280', '282'], 'objectives': ['Explain the services Gall provides to the system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/233.yml\n",
      "/home/neal/urbit/curriculum/lessons/233.yml\n",
      "{'uuid': 233, 'layout': 'node', 'title': 'Functional gates/doors', 'tags': ['%stdlib'], 'prerequisites': ['183', '184'], 'postrequisites': ['288'], 'objectives': ['Reel, roll, turn a list.', 'Curry, cork functions.', 'Change arity of a gate.'], 'runes': [';:'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '\"<!-- 2b, 2n -->\"\\n', 'content': ''}\n",
      "lessons/234.yml\n",
      "/home/neal/urbit/curriculum/lessons/234.yml\n",
      "{'uuid': 234, 'layout': 'node', 'title': 'Floating-point mathematics', 'tags': ['%stdlib'], 'prerequisites': ['163'], 'postrequisites': [], 'objectives': ['Review floating-point mathematics including IEEE-754.', 'Examine `fn` representation of floating-point values.', 'Examine `@r` atomic representation of floating-point values.', 'Manipulate and convert floating-point values using the `@r` operations.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/235.yml\n",
      "/home/neal/urbit/curriculum/lessons/235.yml\n",
      "{'uuid': 235, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%iris'], 'prerequisites': ['201'], 'postrequisites': ['275', '285', '330'], 'objectives': ['Explain the services Iris provides to the system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/236.yml\n",
      "/home/neal/urbit/curriculum/lessons/236.yml\n",
      "{'uuid': 236, 'layout': 'node', 'title': 'Other mathematics', 'tags': ['%stdlib'], 'prerequisites': ['150', '163'], 'postrequisites': [], 'objectives': ['Examine `@s` atomic representation of signed integer values.', 'Use `+si` to manipulate `@s` signed integer values.', 'Examine the rest of the modular arithmetic library, `+fo` and `++egcd`.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/240.yml\n",
      "/home/neal/urbit/curriculum/lessons/240.yml\n",
      "{'uuid': 240, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%jael'], 'prerequisites': ['112', '201'], 'postrequisites': ['290'], 'objectives': ['Explain the services Jael provides to the system.', 'Enumerate the secrets Jael tracks.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/245.yml\n",
      "/home/neal/urbit/curriculum/lessons/245.yml\n",
      "{'uuid': 245, 'layout': 'node', 'title': 'Heuristic description of vane.', 'tags': ['%khan'], 'prerequisites': ['201'], 'postrequisites': ['295'], 'objectives': ['Explain the services Khan provides to the system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/250.yml\n",
      "/home/neal/urbit/curriculum/lessons/250.yml\n",
      "{'uuid': 250, 'layout': 'node', 'title': 'Description of simple rules; derivation of compound rules; explanation of cores.', 'tags': ['%nock'], 'prerequisites': ['115'], 'postrequisites': ['350'], 'objectives': ['Compile Hoon code to Nock using `!=`.', 'Translate and annotate Nock like assembly language.', 'Derive the compound rules of Nock from the simpler rules.'], 'runes': ['!='], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/255.yml\n",
      "/home/neal/urbit/curriculum/lessons/255.yml\n",
      "{'uuid': 255, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%ames'], 'prerequisites': ['205', '180', '222'], 'postrequisites': ['301', '405'], 'objectives': ['Describe internal operations and structures of Ames.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/260.yml\n",
      "/home/neal/urbit/curriculum/lessons/260.yml\n",
      "{'uuid': 260, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%behn'], 'prerequisites': ['210', '180', '222'], 'postrequisites': ['301'], 'objectives': ['Describe internal operations and structures of Behn.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/263.yml\n",
      "/home/neal/urbit/curriculum/lessons/263.yml\n",
      "{'uuid': 263, 'layout': 'node', 'title': 'Producing interactive generators.', 'tags': ['%hoon'], 'prerequisites': ['163', '183'], 'postrequisites': ['370'], 'objectives': ['Produce `%ask` generators.', 'Enumerate the most common cares for Clay.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/265.yml\n",
      "/home/neal/urbit/curriculum/lessons/265.yml\n",
      "{'uuid': 265, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%clay'], 'prerequisites': ['215', '180', '222'], 'postrequisites': ['301', '314'], 'objectives': ['Describe internal operations and structures of Clay.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/270.yml\n",
      "/home/neal/urbit/curriculum/lessons/270.yml\n",
      "{'uuid': 270, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%dill'], 'prerequisites': ['220', '180', '222'], 'postrequisites': ['301', '320'], 'objectives': ['Describe internal operations and structures of Dill.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/275.yml\n",
      "/home/neal/urbit/curriculum/lessons/275.yml\n",
      "{'uuid': 275, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%eyre'], 'prerequisites': ['235', '180', '225', '222'], 'postrequisites': ['301', '500'], 'objectives': ['Describe internal operations and structures of Eyre.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/280.yml\n",
      "/home/neal/urbit/curriculum/lessons/280.yml\n",
      "{'uuid': 280, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%gall'], 'prerequisites': ['230', '180', '222'], 'postrequisites': ['301', '430'], 'objectives': ['Describe internal operations and structures of Gall.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/282.yml\n",
      "/home/neal/urbit/curriculum/lessons/282.yml\n",
      "{'uuid': 282, 'layout': 'node', 'title': 'Production of a simple Gall agent.', 'tags': ['%gall'], 'prerequisites': ['180', '230'], 'postrequisites': ['382', '390', '430'], 'objectives': ['Produce a minimalist Gall agent.', 'Employ the `default-agent` library.', 'Employ the `%dbug` agent wrapper.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/283.yml\n",
      "/home/neal/urbit/curriculum/lessons/283.yml\n",
      "{'uuid': 283, 'layout': 'node', 'title': 'Basic text tokenization', 'tags': ['%stdlib'], 'prerequisites': ['180', '183'], 'postrequisites': ['383'], 'objectives': ['Tokenize text simply using `find` and `trim`.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/284.yml\n",
      "/home/neal/urbit/curriculum/lessons/284.yml\n",
      "{'uuid': 284, 'layout': 'node', 'title': 'Randomness and hashing', 'tags': ['%stdlib'], 'prerequisites': ['180', '183'], 'postrequisites': ['290'], 'objectives': ['Define entropy and its source.', 'Utilize `eny` in a random number generator (`og`).', 'Distinguish insecure hashing (`mug`) from secure hashing (`shax` and friends).'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/285.yml\n",
      "/home/neal/urbit/curriculum/lessons/285.yml\n",
      "{'uuid': 285, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%iris'], 'prerequisites': ['235', '180', '225', '222'], 'postrequisites': ['301'], 'objectives': ['Describe internal operations and structures of Iris.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/288.yml\n",
      "/home/neal/urbit/curriculum/lessons/288.yml\n",
      "{'uuid': 288, 'layout': 'node', 'title': 'Gate genericity (wet gates)', 'tags': ['%hoon'], 'prerequisites': ['233', '180'], 'postrequisites': ['299', '303', '360'], 'objectives': ['Distinguish dry and wet gates.', 'Describe use cases for wet gates (using genericity).'], 'runes': ['|*', '|@'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/290.yml\n",
      "/home/neal/urbit/curriculum/lessons/290.yml\n",
      "{'uuid': 290, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%Jael'], 'prerequisites': ['240', '284', '180', '222'], 'postrequisites': ['301', '302'], 'objectives': ['Describe internal operations and structures of Jael.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/295.yml\n",
      "/home/neal/urbit/curriculum/lessons/295.yml\n",
      "{'uuid': 295, 'layout': 'node', 'title': 'Technical description of vane, including internals.', 'tags': ['%khan'], 'prerequisites': ['245', '180', '222'], 'postrequisites': ['301'], 'objectives': ['Describe internal operations and structures of Khan.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/299.yml\n",
      "/home/neal/urbit/curriculum/lessons/299.yml\n",
      "{'uuid': 299, 'layout': 'node', 'title': 'Core variadicity (gold, iron, lead, zinc)', 'tags': ['%hoon'], 'prerequisites': ['288', '222'], 'postrequisites': ['300', '301', '303', '360'], 'objectives': ['Enumerate and distinguish use cases for dry cores (using variance):', '- Covariant (`%zinc`)', '- Contravariant (`%iron`)', '- Bivariant (`%lead`)', '- Invariant (`%gold`)'], 'runes': ['^|', '^&', '^?', '|~', '|?'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/300.yml\n",
      "/home/neal/urbit/curriculum/lessons/300.yml\n",
      "{'uuid': 300, 'layout': 'node', 'title': 'Moves and move traces', 'tags': ['%arvo'], 'prerequisites': ['200', '299'], 'postrequisites': ['301', '303', '353', '485'], 'objectives': ['Enumerate and dissect all `$move` types.', 'Follow a move trace.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/301.yml\n",
      "/home/neal/urbit/curriculum/lessons/301.yml\n",
      "{'uuid': 301, 'layout': 'node', 'title': 'Technical description of boot process.', 'tags': ['%arvo'], 'prerequisites': ['195', '200', '255', '260', '265', '270', '275', '280', '285', '290', '295', '299', '300'], 'postrequisites': ['304', '500'], 'objectives': ['Outline the Urbit bootstrapping process for a fresh ship launch.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/302.yml\n",
      "/home/neal/urbit/curriculum/lessons/302.yml\n",
      "{'uuid': 302, 'layout': 'node', 'title': 'Management of system state; eth-watcher (also Jael).', 'tags': ['%azimuth'], 'prerequisites': ['102', '290'], 'postrequisites': ['402', '500'], 'objectives': [\"Query and manage Jael's internal system state.\", 'Query the state of the Azimuth PKI from the Ethereum blockchain.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/303.yml\n",
      "/home/neal/urbit/curriculum/lessons/303.yml\n",
      "{'uuid': 303, 'layout': 'node', 'title': 'Advanced debugging techniques', 'tags': ['%testing'], 'prerequisites': ['185', '190', '288', '299', '300'], 'postrequisites': [], 'objectives': ['Enumerate and identify advanced error messages (`mull-grow`, etc.).'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/304.yml\n",
      "/home/neal/urbit/curriculum/lessons/304.yml\n",
      "{'uuid': 304, 'layout': 'node', 'title': 'Describe the subject structure of Arvo and system components.', 'tags': ['%arvo'], 'prerequisites': ['301'], 'postrequisites': ['400'], 'objectives': ['Enumerate and apply internal data structures:  `$arch`, `$beak`, `$beam`, `$bone`, etc.', 'Describe the structure and role of `%zuse`.', 'Describe the structure and role of `%lull`.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/305.yml\n",
      "/home/neal/urbit/curriculum/lessons/305.yml\n",
      "lessons/310.yml\n",
      "/home/neal/urbit/curriculum/lessons/310.yml\n",
      "lessons/314.yml\n",
      "/home/neal/urbit/curriculum/lessons/314.yml\n",
      "{'uuid': 314, 'layout': 'node', 'title': 'Work with marks.', 'tags': ['%clay'], 'prerequisites': ['265'], 'postrequisites': ['315', '382'], 'objectives': ['Diagram how marks convert nouns.', 'Explain the use of the `++grab`, `++grow`, and `++grad` arms.', 'Produce a simple mark.'], 'runes': ['/*'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/315.yml\n",
      "/home/neal/urbit/curriculum/lessons/315.yml\n",
      "{'uuid': 315, 'layout': 'node', 'title': 'Manage desks manually; convert data with tubes; access arbitrary revisions of data.', 'tags': ['%clay'], 'prerequisites': ['265', '314'], 'postrequisites': ['415'], 'objectives': ['Produce a simple mark.'], 'runes': ['/*'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/320.yml\n",
      "/home/neal/urbit/curriculum/lessons/320.yml\n",
      "{'uuid': 320, 'layout': 'node', 'title': 'Inject %belt events; use term/%herm.', 'tags': ['%dill'], 'prerequisites': ['270'], 'postrequisites': ['420'], 'objectives': ['Inject `%belt` events.', 'Use `term` and `%herm` to manage a ship externally.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/325.yml\n",
      "/home/neal/urbit/curriculum/lessons/325.yml\n",
      "lessons/330.yml\n",
      "/home/neal/urbit/curriculum/lessons/330.yml\n",
      "{'uuid': 330, 'layout': 'node', 'title': 'Parsing and reparsing of JSON inputs.', 'tags': ['%api'], 'prerequisites': ['225', '235'], 'postrequisites': ['331', '375', '382'], 'objectives': ['Parse JSON input.', 'Construct a JSON reparser.', 'Convert JSON to other formats with a mark.', 'Retrieve particular values from a JSON input.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/333.yml\n",
      "/home/neal/urbit/curriculum/lessons/333.yml\n",
      "{'uuid': 333, 'layout': 'node', 'title': 'Parsing dates', 'tags': ['%stdlib'], 'prerequisites': ['183'], 'postrequisites': [], 'objectives': ['Represent dates and times using specialized molds.', 'Convert between values.', 'Examine the range and granularity of Urbit time representations.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/335.yml\n",
      "/home/neal/urbit/curriculum/lessons/335.yml\n",
      "lessons/340.yml\n",
      "/home/neal/urbit/curriculum/lessons/340.yml\n",
      "lessons/345.yml\n",
      "/home/neal/urbit/curriculum/lessons/345.yml\n",
      "lessons/350.yml\n",
      "/home/neal/urbit/curriculum/lessons/350.yml\n",
      "{'uuid': 350, 'layout': 'node', 'title': 'Technical description of Hoon builder (Hoon→AST).', 'tags': ['%nock'], 'prerequisites': ['250'], 'postrequisites': ['360', '450'], 'objectives': ['Build Hoon code into ASTs explicitly (`++ream`).'], 'runes': ['!,'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/353.yml\n",
      "/home/neal/urbit/curriculum/lessons/353.yml\n",
      "{'uuid': 353, 'layout': 'node', 'title': 'King/serf operations.', 'tags': ['%runtime'], 'prerequisites': ['300'], 'postrequisites': ['453'], 'objectives': ['Identify role of king and serf in maintaining Arvo system.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/360.yml\n",
      "/home/neal/urbit/curriculum/lessons/360.yml\n",
      "{'uuid': 360, 'layout': 'node', 'title': 'Deep Hoon', 'tags': ['%hoon'], 'prerequisites': ['288', '299', '350'], 'postrequisites': ['433', '483'], 'objectives': ['Distinguish spec and value modes (`$=` v. `^=`).', 'Lift dynamic value into static context (`!<`).', 'Expose a namespace with `=,`.', 'Produce arm chapters in a core.'], 'runes': ['|;', '|^', '$.', '$=', '^=', '=', '', '!<', '+|'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/365.yml\n",
      "/home/neal/urbit/curriculum/lessons/365.yml\n",
      "lessons/370.yml\n",
      "/home/neal/urbit/curriculum/lessons/370.yml\n",
      "{'uuid': 370, 'layout': 'node', 'title': '%shoe/%sole generators', 'tags': ['%cli'], 'prerequisites': ['263'], 'postrequisites': ['383', '470'], 'objectives': ['Use `%shoe` and `%sole` to produce a command-line `%ask` generator.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/375.yml\n",
      "/home/neal/urbit/curriculum/lessons/375.yml\n",
      "{'uuid': 375, 'layout': 'node', 'title': 'Simple front-end operations. (flavored by language)', 'tags': ['%api'], 'prerequisites': ['330', 'external'], 'postrequisites': ['420', '482'], 'objectives': ['Interact with Urbit using Airlock, by language.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/380.yml\n",
      "/home/neal/urbit/curriculum/lessons/380.yml\n",
      "lessons/382.yml\n",
      "/home/neal/urbit/curriculum/lessons/382.yml\n",
      "{'uuid': 382, 'layout': 'node', 'title': 'Advanced agents without front-end interface.', 'tags': ['%gall'], 'prerequisites': ['217', '282', '330'], 'postrequisites': ['482'], 'objectives': ['Produce an advanced Gall agent without a front-end interface.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/383.yml\n",
      "/home/neal/urbit/curriculum/lessons/383.yml\n",
      "{'uuid': 383, 'layout': 'node', 'title': 'Parse text', 'tags': ['%stdlib'], 'prerequisites': ['283', '370'], 'postrequisites': [], 'objectives': ['Identify elements of parsing:  `nail`, `rule`, etc.', 'Use [`++scan`](https://urbit.org/docs/hoon/reference/stdlib/4g#scan) to parse `tape` into atoms.', 'Construct new rules and parse arbitrary text fields.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '\"<!-- 4a, 4d–4l -->\"\\n', 'content': ''}\n",
      "lessons/385.yml\n",
      "/home/neal/urbit/curriculum/lessons/385.yml\n",
      "lessons/390.yml\n",
      "/home/neal/urbit/curriculum/lessons/390.yml\n",
      "{'uuid': 390, 'layout': 'node', 'title': 'CI integration of testing.', 'tags': ['%testing'], 'prerequisites': ['190', '217', '282'], 'postrequisites': ['500'], 'objectives': ['Set up a continuous integration pipeline to test Gall agents and other published code.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '\"<!-- 4a, 4d–4l -->\"\\n', 'content': ''}\n",
      "lessons/395.yml\n",
      "/home/neal/urbit/curriculum/lessons/395.yml\n",
      "lessons/400.yml\n",
      "/home/neal/urbit/curriculum/lessons/400.yml\n",
      "{'uuid': 400, 'layout': 'node', 'title': 'Management of %unix interface; king/serf dynamics.', 'tags': ['%arvo'], 'prerequisites': ['304'], 'postrequisites': ['453', '500'], 'objectives': ['Explore how `%unix` events are treated by the runtime.', 'Examine king/serf dynamics in greater detail.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '\"<!-- 4a, 4d–4l -->\"\\n', 'content': ''}\n",
      "lessons/401.yml\n",
      "/home/neal/urbit/curriculum/lessons/401.yml\n",
      "lessons/402.yml\n",
      "/home/neal/urbit/curriculum/lessons/402.yml\n",
      "{'uuid': 402, 'layout': 'node', 'title': 'Ecliptic contract structure; programmatic Bridge activities; L2.', 'tags': ['%azimuth'], 'prerequisites': ['302', 'Solidity/EVM'], 'postrequisites': [], 'objectives': ['Examine Ecliptic contract structure.', 'Carry out Bridge activities programmatically.', 'Describe how L2 ships work.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/405.yml\n",
      "/home/neal/urbit/curriculum/lessons/405.yml\n",
      "{'uuid': 405, 'layout': 'node', 'title': 'Technical description of network, packets, etc.', 'tags': ['%ames'], 'prerequisites': ['255'], 'postrequisites': ['500'], 'objectives': ['Describe Ames at a technical operating level, such as peer discovery and routing.', 'Diagram the structure of an Ames UDP packet.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/410.yml\n",
      "/home/neal/urbit/curriculum/lessons/410.yml\n",
      "lessons/415.yml\n",
      "/home/neal/urbit/curriculum/lessons/415.yml\n",
      "{'uuid': 415, 'layout': 'node', 'title': 'Produce full marks.', 'tags': ['%clay'], 'prerequisites': ['315'], 'postrequisites': ['500'], 'objectives': ['Produce a mark with all arms defined.', 'Enumerate all remaining cares.'], 'runes': ['/$'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/420.yml\n",
      "/home/neal/urbit/curriculum/lessons/420.yml\n",
      "{'uuid': 420, 'layout': 'node', 'title': 'Manage terminal windows directly (e.g. %webterm).', 'tags': ['%dill'], 'prerequisites': ['320', '375'], 'postrequisites': ['500'], 'objectives': ['Manage terminal windows directly.', 'Examine `%webterm` in detail.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/425.yml\n",
      "/home/neal/urbit/curriculum/lessons/425.yml\n",
      "lessons/430.yml\n",
      "/home/neal/urbit/curriculum/lessons/430.yml\n",
      "{'uuid': 430, 'layout': 'node', 'title': 'Thread composition and management.', 'tags': ['%gall'], 'prerequisites': ['280', '282'], 'postrequisites': ['480'], 'objectives': ['Use Spider to dispatch and manage threads.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/433.yml\n",
      "/home/neal/urbit/curriculum/lessons/433.yml\n",
      "{'uuid': 433, 'layout': 'node', 'title': 'TBD advanced stuff', 'tags': ['%stdlib'], 'prerequisites': ['360'], 'postrequisites': [], 'objectives': [], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/435.yml\n",
      "/home/neal/urbit/curriculum/lessons/435.yml\n",
      "lessons/440.yml\n",
      "/home/neal/urbit/curriculum/lessons/440.yml\n",
      "lessons/445.yml\n",
      "/home/neal/urbit/curriculum/lessons/445.yml\n",
      "lessons/450.yml\n",
      "/home/neal/urbit/curriculum/lessons/450.yml\n",
      "{'uuid': 450, 'layout': 'node', 'title': 'Technical description of Hoon builder (AST→Nock); jet matching.', 'tags': ['%nock'], 'prerequisites': ['350'], 'postrequisites': ['453', '550'], 'objectives': ['Explain how Hoon ASTs map to Nock.', 'Use `++mock` to execute Nock code.', 'Explain how jet matching works in the binary runtime.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/453.yml\n",
      "/home/neal/urbit/curriculum/lessons/453.yml\n",
      "{'uuid': 453, 'layout': 'node', 'title': 'Jet construction/u3; jet dashboard.', 'tags': ['%runtime'], 'prerequisites': ['353', '400', '450'], 'postrequisites': ['550'], 'objectives': ['Use `u3` to produce a jet for a Hoon library.', 'Explain the jet dashboard.'], 'runes': ['~/', '~%', '~+', '~!'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/460.yml\n",
      "/home/neal/urbit/curriculum/lessons/460.yml\n",
      "lessons/465.yml\n",
      "/home/neal/urbit/curriculum/lessons/465.yml\n",
      "lessons/470.yml\n",
      "/home/neal/urbit/curriculum/lessons/470.yml\n",
      "{'uuid': 470, 'layout': 'node', 'title': 'Dojo/Helm/Hood internals.', 'tags': ['%cli'], 'prerequisites': ['370'], 'postrequisites': [], 'objectives': ['Explore Dojo, Helm, Hood, and Drum technical internals.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/475.yml\n",
      "/home/neal/urbit/curriculum/lessons/475.yml\n",
      "lessons/480.yml\n",
      "/home/neal/urbit/curriculum/lessons/480.yml\n",
      "{'uuid': 480, 'layout': 'node', 'title': 'Technical description of Spider as thread handler.', 'tags': ['%gall'], 'prerequisites': ['430'], 'postrequisites': [], 'objectives': ['Describe internal operations and structures of Spider.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/482.yml\n",
      "/home/neal/urbit/curriculum/lessons/482.yml\n",
      "{'uuid': 482, 'layout': 'node', 'title': 'Advanced agents with front-end interface.', 'tags': ['%gall'], 'prerequisites': ['375', '382'], 'postrequisites': [], 'objectives': ['Produce an advanced agent with a front-end interface.', 'Explain the role of a %glob and produce one.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/483.yml\n",
      "/home/neal/urbit/curriculum/lessons/483.yml\n",
      "{'uuid': 483, 'layout': 'node', 'title': 'Advanced Molds', 'tags': ['%hoon'], 'prerequisites': ['350'], 'postrequisites': [], 'objectives': ['Describe advanced mold production with Hoon.'], 'runes': ['$@', '$%', '$<', '$>', '$|', '$&', '$^', '$-', '$~', '$*', '$;'], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/485.yml\n",
      "/home/neal/urbit/curriculum/lessons/485.yml\n",
      "{'uuid': 485, 'layout': 'node', 'title': 'Aqua', 'tags': ['%arvo'], 'prerequisites': ['300'], 'postrequisites': ['500'], 'objectives': ['Use Aqua to test software and network interactions.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/490.yml\n",
      "/home/neal/urbit/curriculum/lessons/490.yml\n",
      "lessons/495.yml\n",
      "/home/neal/urbit/curriculum/lessons/495.yml\n",
      "lessons/500.yml\n",
      "/home/neal/urbit/curriculum/lessons/500.yml\n",
      "{'uuid': 500, 'layout': 'node', 'title': 'OTA production.', 'tags': ['%arvo'], 'prerequisites': ['400', '302', '405', '415', '420', '275', '390', '301', '485'], 'postrequisites': ['550'], 'objectives': ['Produce an over-the-air (OTA) update.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "lessons/550.yml\n",
      "/home/neal/urbit/curriculum/lessons/550.yml\n",
      "{'uuid': 550, 'layout': 'node', 'title': 'Produce working runtime implementation of Arvo.', 'tags': ['%runtime'], 'prerequisites': ['500', '450', '453'], 'postrequisites': [], 'objectives': ['Produce a working runtime implementation of Arvo.'], 'runes': [], 'irregular': [], 'key_points': [], 'assessments': [], 'comments': '', 'content': ''}\n",
      "['%sysadmin'] \"%sysadmin\"\n",
      "'' \n",
      "['%azimuth'] \"%azimuth\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%azimuth'] \"%azimuth\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%testing'] \"%testing\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%testing'] \"%testing\"\n",
      "['%clay'] \"%clay\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%arvo'] \"%arvo\"\n",
      "['%arvo'] \"%arvo\"\n",
      "'' \n",
      "['%ames'] \"%ames\"\n",
      "['%behn'] \"%behn\"\n",
      "['%clay'] \"%clay\"\n",
      "['%clay'] \"%clay\"\n",
      "['%dill'] \"%dill\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%eyre'] \"%eyre\"\n",
      "['%gall'] \"%gall\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%iris'] \"%iris\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%jael'] \"%jael\"\n",
      "['%khan'] \"%khan\"\n",
      "['%nock'] \"%nock\"\n",
      "['%ames'] \"%ames\"\n",
      "['%behn'] \"%behn\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%clay'] \"%clay\"\n",
      "['%dill'] \"%dill\"\n",
      "['%eyre'] \"%eyre\"\n",
      "['%gall'] \"%gall\"\n",
      "['%gall'] \"%gall\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "['%iris'] \"%iris\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%Jael'] \"%Jael\"\n",
      "['%khan'] \"%khan\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%arvo'] \"%arvo\"\n",
      "['%arvo'] \"%arvo\"\n",
      "['%azimuth'] \"%azimuth\"\n",
      "['%testing'] \"%testing\"\n",
      "['%arvo'] \"%arvo\"\n",
      "'' \n",
      "'' \n",
      "['%clay'] \"%clay\"\n",
      "['%clay'] \"%clay\"\n",
      "['%dill'] \"%dill\"\n",
      "'' \n",
      "['%api'] \"%api\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "'' \n",
      "'' \n",
      "'' \n",
      "['%nock'] \"%nock\"\n",
      "['%runtime'] \"%runtime\"\n",
      "['%hoon'] \"%hoon\"\n",
      "'' \n",
      "['%cli'] \"%cli\"\n",
      "['%api'] \"%api\"\n",
      "'' \n",
      "['%gall'] \"%gall\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "'' \n",
      "['%testing'] \"%testing\"\n",
      "'' \n",
      "['%arvo'] \"%arvo\"\n",
      "'' \n",
      "['%azimuth'] \"%azimuth\"\n",
      "['%ames'] \"%ames\"\n",
      "'' \n",
      "['%clay'] \"%clay\"\n",
      "['%dill'] \"%dill\"\n",
      "'' \n",
      "['%gall'] \"%gall\"\n",
      "['%stdlib'] \"%stdlib\"\n",
      "'' \n",
      "'' \n",
      "'' \n",
      "['%nock'] \"%nock\"\n",
      "['%runtime'] \"%runtime\"\n",
      "'' \n",
      "'' \n",
      "['%cli'] \"%cli\"\n",
      "'' \n",
      "['%gall'] \"%gall\"\n",
      "['%gall'] \"%gall\"\n",
      "['%hoon'] \"%hoon\"\n",
      "['%arvo'] \"%arvo\"\n",
      "'' \n",
      "'' \n",
      "['%arvo'] \"%arvo\"\n",
      "['%runtime'] \"%runtime\"\n"
     ]
    }
   ],
   "source": [
    "from glob import glob\n",
    "import yaml\n",
    "\n",
    "lessons = sorted(glob('lessons/*.yml'))\n",
    "\n",
    "nodes = {}\n",
    "for lesson in lessons:\n",
    "    # whatever your local path is\n",
    "    print(lesson)\n",
    "    fname = f'/home/neal/urbit/curriculum/{lesson}'\n",
    "    print(fname)\n",
    "    with open(fname, 'r') as f:\n",
    "        data = f.read()\n",
    "    data = yaml.safe_load(data)\n",
    "    if data is None:\n",
    "        node_title = lesson[8:11]\n",
    "        nodes[node_title] = {}\n",
    "        nodes[node_title]['prerequisites'] = ''\n",
    "        nodes[node_title]['title'] = 'Placeholder'\n",
    "        nodes[node_title]['tags'] = ''\n",
    "        continue\n",
    "    print(data)\n",
    "    node_title = lesson[8:11]\n",
    "    nodes[node_title] = {}\n",
    "    nodes[node_title]['prerequisites'] = data['prerequisites']\n",
    "    nodes[node_title]['title'] = data['title']\n",
    "    nodes[node_title]['tags'] = data['tags']\n",
    "\n",
    "full_output = \"#,Topic,Competency Cluster,,Antecedents\\n\"\n",
    "for node in sorted(nodes.keys()):\n",
    "    output = f'{node},'\n",
    "    tag = repr(nodes[node][\"tags\"])\n",
    "    if tag == '':  tag = \"Placeholder\"\n",
    "    print(tag, tag.replace(\"[\",\"\\\"\").replace(\"]\",\"\\\"\").replace(\"'\",\"\"))\n",
    "    output += tag.replace(\"[\",\"\\\"\").replace(\"]\",\"\\\"\").replace(\"'\",\"\") + \",\\\"\"\n",
    "    output += f'{nodes[node][\"title\"]}'+'\",,'\n",
    "    prereq = repr(nodes[node][\"prerequisites\"])\n",
    "    output += prereq.replace(\"[\",\"\\\"\").replace(\"]\",\"\\\"\").replace(\"'\",\"\")\n",
    "    full_output += output + '\\n'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "90bb63d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#,Topic,Competency Cluster,,Antecedents\n",
      "100,\"%sysadmin\",\"Administer an Urbit ship manuaully.\",,\"0\"\n",
      "101,,\"Placeholder\",,\n",
      "102,\"%azimuth\",\"Description of address space structure.\",,\"0\"\n",
      "103,\"%hoon\",\"Aural Hoon\",,\"0\"\n",
      "110,\"%hoon\",\"Syntax, nouns, auras\",,\"100, 103\"\n",
      "112,\"%azimuth\",\"Exploration of address space structure.\",,\"102, 110\"\n",
      "113,\"%hoon\",\"Naked generator design, syncing, etc., control structures\",,\"110\"\n",
      "115,\"%hoon\",\"Irregular forms, sugar syntax\",,\"113\"\n",
      "120,\"%hoon\",\"Basic dry gates\",,\"115\"\n",
      "125,\"%hoon\",\"Molds, typechecking\",,\"120\"\n",
      "130,\"%hoon\",\"Traps, recursion\",,\"125\"\n",
      "133,\"%hoon\",\"Basic cores, arms\",,\"130\"\n",
      "135,\"%hoon\",\"Addressing, trees\",,\"133\"\n",
      "140,\"%stdlib\",\"Lists, trees\",,\"135\"\n",
      "145,\"%hoon\",\"Libraries\",,\"140\"\n",
      "150,\"%hoon\",\"Doors\",,\"145\"\n",
      "153,\"%hoon\",\"The beak\",,\"145\"\n",
      "155,\"%hoon\",\"Revisiting Cores\",,\"150\"\n",
      "156,\"%hoon\",\"Typechecking\",,\"133\"\n",
      "160,\"%stdlib\",\"Basic text transformations\",,\"125\"\n",
      "163,\"%hoon\",\"Producing textually rich %say generators.\",,\"145\"\n",
      "165,\"%hoon\",\"Subject-oriented programming\",,\"155\"\n",
      "170,\"%testing\",\"Basic debugging techniques\",,\"135\"\n",
      "175,\"%hoon\",\"Building code\",,\"115\"\n",
      "180,\"%hoon\",\"State: tisket etc.\",,\"165, 175\"\n",
      "183,\"%hoon\",\"Sets, maps, jars, jugs\",,\"150\"\n",
      "184,\"%hoon\",\"Loobean operations\",,\"156\"\n",
      "185,\"%stdlib\",\"I/O: Tanks, tangs, wains, wangs, and whangdoodles\",,\"160, 170\"\n",
      "188,\"%hoon\",\"Producing interactive %ask generators.\",,\"163, 185\"\n",
      "190,\"%testing\",\"Unit tests with -test thread.\",,\"170\"\n",
      "192,\"%clay\",\"Distribution of desks without dockets.\",,\"190\"\n",
      "195,\"%hoon\",\"Nature of jammed nouns.\",,\"113\"\n",
      "200,\"%arvo\",\"State machine/event log\",,\"0\"\n",
      "201,\"%arvo\",\"Moves\",,\"115, 200\"\n",
      "202,,\"Placeholder\",,\n",
      "205,\"%ames\",\"Heuristic description of vane.\",,\"201\"\n",
      "210,\"%behn\",\"Heuristic description of vane.\",,\"201\"\n",
      "215,\"%clay\",\"Heuristic description of vane; use of marks to convert data.\",,\"201, 115\"\n",
      "217,\"%clay\",\"Distribution of software using Grid.\",,\"192, 215\"\n",
      "220,\"%dill\",\"Heuristic description of vane.\",,\"201\"\n",
      "222,\"%hoon\",\"Molds and mold builders\",,\"150\"\n",
      "225,\"%eyre\",\"Heuristic description of vane.\",,\"201\"\n",
      "230,\"%gall\",\"Heuristic description of vane.\",,\"201\"\n",
      "233,\"%stdlib\",\"Functional gates/doors\",,\"183, 184\"\n",
      "234,\"%stdlib\",\"Floating-point mathematics\",,\"163\"\n",
      "235,\"%iris\",\"Heuristic description of vane.\",,\"201\"\n",
      "236,\"%stdlib\",\"Other mathematics\",,\"150, 163\"\n",
      "240,\"%jael\",\"Heuristic description of vane.\",,\"112, 201\"\n",
      "245,\"%khan\",\"Heuristic description of vane.\",,\"201\"\n",
      "250,\"%nock\",\"Description of simple rules; derivation of compound rules; explanation of cores.\",,\"115\"\n",
      "255,\"%ames\",\"Technical description of vane, including internals.\",,\"205, 180, 222\"\n",
      "260,\"%behn\",\"Technical description of vane, including internals.\",,\"210, 180, 222\"\n",
      "263,\"%hoon\",\"Producing interactive generators.\",,\"163, 183\"\n",
      "265,\"%clay\",\"Technical description of vane, including internals.\",,\"215, 180, 222\"\n",
      "270,\"%dill\",\"Technical description of vane, including internals.\",,\"220, 180, 222\"\n",
      "275,\"%eyre\",\"Technical description of vane, including internals.\",,\"235, 180, 225, 222\"\n",
      "280,\"%gall\",\"Technical description of vane, including internals.\",,\"230, 180, 222\"\n",
      "282,\"%gall\",\"Production of a simple Gall agent.\",,\"180, 230\"\n",
      "283,\"%stdlib\",\"Basic text tokenization\",,\"180, 183\"\n",
      "284,\"%stdlib\",\"Randomness and hashing\",,\"180, 183\"\n",
      "285,\"%iris\",\"Technical description of vane, including internals.\",,\"235, 180, 225, 222\"\n",
      "288,\"%hoon\",\"Gate genericity (wet gates)\",,\"233, 180\"\n",
      "290,\"%Jael\",\"Technical description of vane, including internals.\",,\"240, 284, 180, 222\"\n",
      "295,\"%khan\",\"Technical description of vane, including internals.\",,\"245, 180, 222\"\n",
      "299,\"%hoon\",\"Core variadicity (gold, iron, lead, zinc)\",,\"288, 222\"\n",
      "300,\"%arvo\",\"Moves and move traces\",,\"200, 299\"\n",
      "301,\"%arvo\",\"Technical description of boot process.\",,\"195, 200, 255, 260, 265, 270, 275, 280, 285, 290, 295, 299, 300\"\n",
      "302,\"%azimuth\",\"Management of system state; eth-watcher (also Jael).\",,\"102, 290\"\n",
      "303,\"%testing\",\"Advanced debugging techniques\",,\"185, 190, 288, 299, 300\"\n",
      "304,\"%arvo\",\"Describe the subject structure of Arvo and system components.\",,\"301\"\n",
      "305,,\"Placeholder\",,\n",
      "310,,\"Placeholder\",,\n",
      "314,\"%clay\",\"Work with marks.\",,\"265\"\n",
      "315,\"%clay\",\"Manage desks manually; convert data with tubes; access arbitrary revisions of data.\",,\"265, 314\"\n",
      "320,\"%dill\",\"Inject %belt events; use term/%herm.\",,\"270\"\n",
      "325,,\"Placeholder\",,\n",
      "330,\"%api\",\"Parsing and reparsing of JSON inputs.\",,\"225, 235\"\n",
      "333,\"%stdlib\",\"Parsing dates\",,\"183\"\n",
      "335,,\"Placeholder\",,\n",
      "340,,\"Placeholder\",,\n",
      "345,,\"Placeholder\",,\n",
      "350,\"%nock\",\"Technical description of Hoon builder (Hoon→AST).\",,\"250\"\n",
      "353,\"%runtime\",\"King/serf operations.\",,\"300\"\n",
      "360,\"%hoon\",\"Deep Hoon\",,\"288, 299, 350\"\n",
      "365,,\"Placeholder\",,\n",
      "370,\"%cli\",\"%shoe/%sole generators\",,\"263\"\n",
      "375,\"%api\",\"Simple front-end operations. (flavored by language)\",,\"330, external\"\n",
      "380,,\"Placeholder\",,\n",
      "382,\"%gall\",\"Advanced agents without front-end interface.\",,\"217, 282, 330\"\n",
      "383,\"%stdlib\",\"Parse text\",,\"283, 370\"\n",
      "385,,\"Placeholder\",,\n",
      "390,\"%testing\",\"CI integration of testing.\",,\"190, 217, 282\"\n",
      "395,,\"Placeholder\",,\n",
      "400,\"%arvo\",\"Management of %unix interface; king/serf dynamics.\",,\"304\"\n",
      "401,,\"Placeholder\",,\n",
      "402,\"%azimuth\",\"Ecliptic contract structure; programmatic Bridge activities; L2.\",,\"302, Solidity/EVM\"\n",
      "405,\"%ames\",\"Technical description of network, packets, etc.\",,\"255\"\n",
      "410,,\"Placeholder\",,\n",
      "415,\"%clay\",\"Produce full marks.\",,\"315\"\n",
      "420,\"%dill\",\"Manage terminal windows directly (e.g. %webterm).\",,\"320, 375\"\n",
      "425,,\"Placeholder\",,\n",
      "430,\"%gall\",\"Thread composition and management.\",,\"280, 282\"\n",
      "433,\"%stdlib\",\"TBD advanced stuff\",,\"360\"\n",
      "435,,\"Placeholder\",,\n",
      "440,,\"Placeholder\",,\n",
      "445,,\"Placeholder\",,\n",
      "450,\"%nock\",\"Technical description of Hoon builder (AST→Nock); jet matching.\",,\"350\"\n",
      "453,\"%runtime\",\"Jet construction/u3; jet dashboard.\",,\"353, 400, 450\"\n",
      "460,,\"Placeholder\",,\n",
      "465,,\"Placeholder\",,\n",
      "470,\"%cli\",\"Dojo/Helm/Hood internals.\",,\"370\"\n",
      "475,,\"Placeholder\",,\n",
      "480,\"%gall\",\"Technical description of Spider as thread handler.\",,\"430\"\n",
      "482,\"%gall\",\"Advanced agents with front-end interface.\",,\"375, 382\"\n",
      "483,\"%hoon\",\"Advanced Molds\",,\"350\"\n",
      "485,\"%arvo\",\"Aqua\",,\"300\"\n",
      "490,,\"Placeholder\",,\n",
      "495,,\"Placeholder\",,\n",
      "500,\"%arvo\",\"OTA production.\",,\"400, 302, 405, 415, 420, 275, 390, 301, 485\"\n",
      "550,\"%runtime\",\"Produce working runtime implementation of Arvo.\",,\"500, 450, 453\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(full_output)\n",
    "with open('curr-raw.csv', 'w') as outfile:\n",
    "    outfile.write(full_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca512141",
   "metadata": {},
   "source": [
    "##  Load and clean CSV of nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e57d5aac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and clean CSV of nodes and descriptions.\n",
    "from csv import DictReader\n",
    "\n",
    "nodes = {}\n",
    "edges = {}\n",
    "with open('curr-raw.csv', 'r') as rawFile:\n",
    "    rawData = DictReader(rawFile)\n",
    "    \n",
    "    # Build nodes.\n",
    "    for line in rawData:\n",
    "        if line[\"Topic\"] in ['', 'Aggregate'] or line[\"Competency Cluster\"] in '': continue\n",
    "        nodes[line['#']] = f'{line[\"Topic\"]}: {line[\"Competency Cluster\"]}'\n",
    "        \n",
    "        if line['Antecedents'].strip() == '': continue\n",
    "        edges[line['#']] = []\n",
    "        ants = line['Antecedents'].split(',')\n",
    "        for ante in ants:\n",
    "            if line[\"Antecedents\"].strip() == '0': continue\n",
    "            edges[line['#']].append(ante.strip())\n",
    "            #print(line['#'], edges[line['#']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1e96d171",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'100': '%sysadmin: Administer an Urbit ship manuaully.',\n",
       " '102': '%azimuth: Description of address space structure.',\n",
       " '103': '%hoon: Aural Hoon',\n",
       " '110': '%hoon: Syntax, nouns, auras',\n",
       " '112': '%azimuth: Exploration of address space structure.',\n",
       " '113': '%hoon: Naked generator design, syncing, etc., control structures',\n",
       " '115': '%hoon: Irregular forms, sugar syntax',\n",
       " '120': '%hoon: Basic dry gates',\n",
       " '125': '%hoon: Molds, typechecking',\n",
       " '130': '%hoon: Traps, recursion',\n",
       " '133': '%hoon: Basic cores, arms',\n",
       " '135': '%hoon: Addressing, trees',\n",
       " '140': '%stdlib: Lists, trees',\n",
       " '145': '%hoon: Libraries',\n",
       " '150': '%hoon: Doors',\n",
       " '153': '%hoon: The beak',\n",
       " '155': '%hoon: Revisiting Cores',\n",
       " '156': '%hoon: Typechecking',\n",
       " '160': '%stdlib: Basic text transformations',\n",
       " '163': '%hoon: Producing textually rich %say generators.',\n",
       " '165': '%hoon: Subject-oriented programming',\n",
       " '170': '%testing: Basic debugging techniques',\n",
       " '175': '%hoon: Building code',\n",
       " '180': '%hoon: State: tisket etc.',\n",
       " '183': '%hoon: Sets, maps, jars, jugs',\n",
       " '184': '%hoon: Loobean operations',\n",
       " '185': '%stdlib: I/O: Tanks, tangs, wains, wangs, and whangdoodles',\n",
       " '188': '%hoon: Producing interactive %ask generators.',\n",
       " '190': '%testing: Unit tests with -test thread.',\n",
       " '192': '%clay: Distribution of desks without dockets.',\n",
       " '195': '%hoon: Nature of jammed nouns.',\n",
       " '200': '%arvo: State machine/event log',\n",
       " '201': '%arvo: Moves',\n",
       " '205': '%ames: Heuristic description of vane.',\n",
       " '210': '%behn: Heuristic description of vane.',\n",
       " '215': '%clay: Heuristic description of vane; use of marks to convert data.',\n",
       " '217': '%clay: Distribution of software using Grid.',\n",
       " '220': '%dill: Heuristic description of vane.',\n",
       " '222': '%hoon: Molds and mold builders',\n",
       " '225': '%eyre: Heuristic description of vane.',\n",
       " '230': '%gall: Heuristic description of vane.',\n",
       " '233': '%stdlib: Functional gates/doors',\n",
       " '234': '%stdlib: Floating-point mathematics',\n",
       " '235': '%iris: Heuristic description of vane.',\n",
       " '236': '%stdlib: Other mathematics',\n",
       " '240': '%jael: Heuristic description of vane.',\n",
       " '245': '%khan: Heuristic description of vane.',\n",
       " '250': '%nock: Description of simple rules; derivation of compound rules; explanation of cores.',\n",
       " '255': '%ames: Technical description of vane, including internals.',\n",
       " '260': '%behn: Technical description of vane, including internals.',\n",
       " '263': '%hoon: Producing interactive generators.',\n",
       " '265': '%clay: Technical description of vane, including internals.',\n",
       " '270': '%dill: Technical description of vane, including internals.',\n",
       " '275': '%eyre: Technical description of vane, including internals.',\n",
       " '280': '%gall: Technical description of vane, including internals.',\n",
       " '282': '%gall: Production of a simple Gall agent.',\n",
       " '283': '%stdlib: Basic text tokenization',\n",
       " '284': '%stdlib: Randomness and hashing',\n",
       " '285': '%iris: Technical description of vane, including internals.',\n",
       " '288': '%hoon: Gate genericity (wet gates)',\n",
       " '290': '%Jael: Technical description of vane, including internals.',\n",
       " '295': '%khan: Technical description of vane, including internals.',\n",
       " '299': '%hoon: Core variadicity (gold, iron, lead, zinc)',\n",
       " '300': '%arvo: Moves and move traces',\n",
       " '301': '%arvo: Technical description of boot process.',\n",
       " '302': '%azimuth: Management of system state; eth-watcher (also Jael).',\n",
       " '303': '%testing: Advanced debugging techniques',\n",
       " '304': '%arvo: Describe the subject structure of Arvo and system components.',\n",
       " '314': '%clay: Work with marks.',\n",
       " '315': '%clay: Manage desks manually; convert data with tubes; access arbitrary revisions of data.',\n",
       " '320': '%dill: Inject %belt events; use term/%herm.',\n",
       " '330': '%api: Parsing and reparsing of JSON inputs.',\n",
       " '333': '%stdlib: Parsing dates',\n",
       " '350': '%nock: Technical description of Hoon builder (Hoon→AST).',\n",
       " '353': '%runtime: King/serf operations.',\n",
       " '360': '%hoon: Deep Hoon',\n",
       " '370': '%cli: %shoe/%sole generators',\n",
       " '375': '%api: Simple front-end operations. (flavored by language)',\n",
       " '382': '%gall: Advanced agents without front-end interface.',\n",
       " '383': '%stdlib: Parse text',\n",
       " '390': '%testing: CI integration of testing.',\n",
       " '400': '%arvo: Management of %unix interface; king/serf dynamics.',\n",
       " '402': '%azimuth: Ecliptic contract structure; programmatic Bridge activities; L2.',\n",
       " '405': '%ames: Technical description of network, packets, etc.',\n",
       " '415': '%clay: Produce full marks.',\n",
       " '420': '%dill: Manage terminal windows directly (e.g. %webterm).',\n",
       " '430': '%gall: Thread composition and management.',\n",
       " '433': '%stdlib: TBD advanced stuff',\n",
       " '450': '%nock: Technical description of Hoon builder (AST→Nock); jet matching.',\n",
       " '453': '%runtime: Jet construction/u3; jet dashboard.',\n",
       " '470': '%cli: Dojo/Helm/Hood internals.',\n",
       " '480': '%gall: Technical description of Spider as thread handler.',\n",
       " '482': '%gall: Advanced agents with front-end interface.',\n",
       " '483': '%hoon: Advanced Molds',\n",
       " '485': '%arvo: Aqua',\n",
       " '500': '%arvo: OTA production.',\n",
       " '550': '%runtime: Produce working runtime implementation of Arvo.'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1908b28c",
   "metadata": {},
   "source": [
    "##  Convert to graph representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ec86a33b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pygraphviz as pgv\n",
    "\n",
    "G = pgv.AGraph(edges,\n",
    "               strict=True,\n",
    "               directed=True,\n",
    "               rankdir=\"RL\",\n",
    "               ranksep=\"0.25\",\n",
    "               ordering=\"in\")\n",
    "\n",
    "G.layout('dot')\n",
    "G.draw('curr.png')\n",
    "G.draw('curr.svg')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c894313b",
   "metadata": {},
   "source": [
    "##  Manually build palette for Hoon School topics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c4bab164",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = '''100\n",
    "110, 113, 103\n",
    "115, 120, 125, 175\n",
    "130, 133, 135\n",
    "140, 145, 160\n",
    "150, 153, 155, 165\n",
    "156, 183\n",
    "184, 233\n",
    "163, 180\n",
    "170, 190, 217'''\n",
    "\n",
    "colors = {\n",
    "    0:'#d8495f',\n",
    "    1:'#d25935',\n",
    "    2:'#ae7b38',\n",
    "    3:'#41945e',\n",
    "    4:'#328c7b',\n",
    "    5:'#32909e',\n",
    "    6:'#5d73d7',\n",
    "    7:'#8633d0',\n",
    "    8:'#904493',\n",
    "    9:'#cc3284',\n",
    "}\n",
    "#http://colrd.com/palette/18894/ \"Spectral 10\" by \n",
    "nodes = {}\n",
    "for idx,row in enumerate(data.split('\\n')):\n",
    "    for val in row.split(','):\n",
    "        nodes[val.strip()] = colors[idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b2c032e",
   "metadata": {},
   "source": [
    "##  Mark SVG nodes by color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f6911450",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here\n"
     ]
    }
   ],
   "source": [
    "from bs4 import BeautifulSoup\n",
    "import re\n",
    "\n",
    "with open('curr.svg') as f:\n",
    "    svg = f.read()\n",
    "\n",
    "soup = BeautifulSoup(svg, 'lxml')\n",
    "\n",
    "svg_tag = soup.find('svg')\n",
    "svg_grf = svg_tag.find('g')\n",
    "paths = svg_grf.find_all('g', {'class': 'node'})\n",
    "\n",
    "for path in paths:\n",
    "    try:\n",
    "        title = path.findChild('title')\n",
    "    except:\n",
    "        continue\n",
    "    if title.contents[0] in nodes:\n",
    "        ellipse = path.findChild('ellipse')\n",
    "        color = nodes[title.contents[0]]\n",
    "        ellipse['fill'] = f'{color}'\n",
    "        if title.contents[0] == '217':\n",
    "            print('here')\n",
    "            #style=\"fill: url(#circles-1) #fff;\"\n",
    "            ellipse['fill'] = f'url(#diagonalHatch) {color}';\n",
    "            pass\n",
    "\n",
    "with open('curr-marked.svg', 'w') as f:\n",
    "    svg = '''<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\\n \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">'''\n",
    "    color = colors[9]\n",
    "    svg_str = str(svg_tag)\n",
    "    idx = svg_str.find('<g')\n",
    "    svg_hdr = svg_str[:idx]\n",
    "    svg_defs = f'''<defs><pattern id=\"diagonalHatch\" width=\"4\" height=\"8\" patternTransform=\"rotate(-45 2 2)\" patternUnits=\"userSpaceOnUse\"><path d=\"M -1,2 l 6,0\" stroke=\"{color}\" stroke-width=\"4\"/></pattern></defs>'''\n",
    "    svg_str = svg+'\\n'+svg_hdr+svg_defs+'\\n'+svg_str[idx:]\n",
    "    f.write(svg_str)\n",
    "    \n",
    "from cairosvg import svg2png\n",
    "svg2png(bytestring=(svg+str(svg_tag)), dpi=100, write_to='curr-marked.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc762dea",
   "metadata": {},
   "source": [
    "##  Build objectives list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5299af68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After Lesson 0, you should be able to:\n",
      "\n",
      "- Explain what an Urbit ship is.\n",
      "- Identify the `.urb/` directory.\n",
      "- Distinguish a fakeship from a liveship.\n",
      "- Use the `+ls` generator to show a directory's contents.\n",
      "- `|mount` and `|commit` a desk.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 1, you should be able to:\n",
      "\n",
      "- Distinguish nouns, cells, and atoms.\n",
      "- Apply auras to transform an atom.\n",
      "- Identify common Hoon molds, such as cells, lists, and tapes.\n",
      "- Annotate Hoon code with comments.\n",
      "- Pin a face to the subject.\n",
      "- Make a decision at a branch point.\n",
      "- Distinguish loobean from boolean operations.\n",
      "- Slam a gate (call a function).\n",
      "- Produce a generator to convert a value between auras.\n",
      "- Pronounce ASCII characters per standard Hoon developer practice.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `::`\n",
      "- `%-`\n",
      "- `=/`\n",
      "- `?:`\n",
      "- `^-`\n",
      "- `~&`\n",
      "- ``\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 2, you should be able to:\n",
      "\n",
      "- Identify current known irregular syntax.\n",
      "- Convert between regular and irregular forms of runes to date.\n",
      "- Employ a gate to defer a computation.\n",
      "- Produce a gate as a generator.\n",
      "- Identify a mold in the hierarchy of Urbit types (nouns, molds, marks).\n",
      "- Understand how type inference and type checking takes place.\n",
      "- Bunt a mold.\n",
      "- Produce a type union.\n",
      "- Produce a named tuple.\n",
      "- Identify type using `!>`.\n",
      "- Build code samples with `-build-file` thread.\n",
      "- Discuss Ford import runes.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `|=`\n",
      "- `!!`\n",
      "- `^+`\n",
      "- `$?`\n",
      "- `$_`\n",
      "- `$:`\n",
      "- `^*`\n",
      "- `!>`\n",
      "- `/-`\n",
      "- `/*`\n",
      "- `/=`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 3, you should be able to:\n",
      "\n",
      "- Employ a trap to produce a reentrant block of code.\n",
      "- Produce a recursive gate.\n",
      "- Distinguish head and tail recursion.\n",
      "- Consider Hoon structures as cores.\n",
      "- Identify the special role of the `$` buc arm in many cores.\n",
      "- Order neighboring cores within the subject for addressibility.\n",
      "- Address nodes in a tree using numeric notation.\n",
      "- Address nodes in a tree using lark notation.\n",
      "- Address data in a tree using faces.\n",
      "- Distinguish `.` and `:` notation.\n",
      "- Diagram Hoon structures such as gates into the corresponding abstract syntax tree.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `|-`\n",
      "- `.+`\n",
      "- `%=`\n",
      "- `|%`\n",
      "- `++`\n",
      "- `+$`\n",
      "- `=<`\n",
      "- `=>`\n",
      "- `=+`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 4, you should be able to:\n",
      "\n",
      "- Use lists to organize data.\n",
      "- Convert between kinds of lists (e.g. tapes).\n",
      "- Diagram lists as binary trees.\n",
      "- Operate on list elements using `snag`, `find`, `weld`, etc.\n",
      "- Import a library using `/+` faslus.\n",
      "- Create a new library in `/lib`.\n",
      "- Review Unicode text structure.\n",
      "- Distinguish cords and tapes and their characteristics.\n",
      "- Transform and manipulate text using text conversion arms: - `++crip`: convert `tape` to `cord` (`tape`→`cord`) - `++trip`: convert `cord` to `tape` (`cord`→`tape`) - `++cass`: convert upper-case text to lower-case (`tape`→`tape`) - `++cuss`: convert lower-case text to upper-case (`tape`→`tape`) - [`++scot`](https://urbit.org/docs/reference/library/4m/#scot): render `dime` as `cord` (`dime`→`cord`) - [`++scow`](https://urbit.org/docs/reference/library/4m/#scow): render `dime` as `tape` (`dime`→`tape`)\n",
      "- Interpolate text.\n",
      "- Employ sigpam logging levels.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `/+`\n",
      "- `~&  >>>`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 5, you should be able to:\n",
      "\n",
      "- Identify the structure of a door and relate it to a core.\n",
      "- Pull an arm in a door.\n",
      "- Build cores for later use and with custom samples.\n",
      "- Identify the `$` buc arm in several structures and its role.\n",
      "- Review subject-oriented programming as a design paradigm.\n",
      "- Explain how Hoon manages the subject and wing search paths.\n",
      "- Explain how to skip to particular matches in a wing search path through the subject.\n",
      "- Identify common Hoon patterns: batteries, and doors, arms, wings, and legs.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `|_`\n",
      "- `%~`\n",
      "- `|.`\n",
      "- `|:`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 6, you should be able to:\n",
      "\n",
      "- Use assertions to enforce type constraints.\n",
      "- Identify a `lest` (as opposed to a list).\n",
      "- Produce a type arm.\n",
      "- Identify units, sets, maps, and compound structures like jars and jugs.\n",
      "- Explain why units and vases are necessary.\n",
      "- Use helper arms and syntax:  `` ` ``, `biff`, `some`, etc.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `?>`\n",
      "- `?<`\n",
      "- `?~`\n",
      "- `+$`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 7, you should be able to:\n",
      "\n",
      "- Produce loobean expressions.\n",
      "- Reorder conditional arms.\n",
      "- Switch against a union with or without default.\n",
      "- Reel, roll, turn a list.\n",
      "- Curry, cork functions.\n",
      "- Change arity of a gate.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `?|`\n",
      "- `?&`\n",
      "- `?!`\n",
      "- `?.`\n",
      "- `?-`\n",
      "- `?+`\n",
      "- `;:`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 8, you should be able to:\n",
      "\n",
      "- Create a `%say` generator.\n",
      "- Identify how Dojo sees and interprets a generator as a cell with a head tag.\n",
      "- Identify the elements of a `sample` for a `%say` generator.\n",
      "- Produce a `%say` generator with optional arguments.\n",
      "- Discuss stateful v. stateless applications and path dependence.\n",
      "- Enumerate Hoon's tools for dealing with state:  `=.` tisdot, `=^` tisket, `;<` micgal, `;~` micsig.\n",
      "- Defer a computation.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `:-`\n",
      "- `=.`\n",
      "- `=^`\n",
      "- `=~`\n",
      "- `;<`\n",
      "- `;~`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 9, you should be able to:\n",
      "\n",
      "- Distinguish errors, faults, and failures.\n",
      "- Distinguish latent, masked, and manifest errors.\n",
      "- Enumerate and identify common error messages.\n",
      "- Employ a debugging strategy to identify and correct errors in Hoon code.\n",
      "- Run existing unit tests.\n",
      "- Produce a unit test.\n",
      "- Produce a desk suitable for distribution (with a docket file).\n",
      "- Install and distribute software.\n",
      "- Explain elements of a docket file.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `!:`\n",
      "- `!.`\n",
      "\n",
      "---\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = '''100\n",
    "110, 113, 103\n",
    "115, 120, 125, 175\n",
    "130, 133, 135\n",
    "140, 145, 160\n",
    "150, 155, 165\n",
    "156, 183\n",
    "184, 233\n",
    "163, 180\n",
    "170, 190, 217'''\n",
    "\n",
    "lessons = {}\n",
    "for idx,row in enumerate(data.split('\\n')):\n",
    "    lessons[idx] = []\n",
    "    for val in row.split(','):\n",
    "        lessons[idx].append(val.strip())\n",
    "\n",
    "import yaml\n",
    "for lesson in lessons:\n",
    "    print(f'After Lesson {lesson}, you should be able to:\\n')\n",
    "    for node in lessons[lesson]:\n",
    "        # whatever your local path is\n",
    "        fname = f'/home/neal/urbit/curriculum/lessons/{node}.yml'\n",
    "        with open(fname, 'r') as f:\n",
    "            data = f.read()\n",
    "        data = yaml.safe_load(data)\n",
    "        for obj in data['objectives']:\n",
    "            print('-', obj)\n",
    "    \n",
    "    print('\\nYou will know the runes:\\n')\n",
    "    for node in lessons[lesson]:\n",
    "        # whatever your local path is\n",
    "        fname = f'/home/neal/urbit/curriculum/lessons/{node}.yml'\n",
    "        with open(fname, 'r') as f:\n",
    "            data = f.read()\n",
    "        data = yaml.safe_load(data)\n",
    "            \n",
    "        for rune in data['runes']:\n",
    "            print(f'- `{rune}`')\n",
    "    print('\\n---\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "68dd0131",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: ['100'],\n",
       " 1: ['110', '113', '103'],\n",
       " 2: ['115', '120', '125', '175'],\n",
       " 3: ['130', '133', '135'],\n",
       " 4: ['140', '145', '160'],\n",
       " 5: ['150', '155', '165'],\n",
       " 6: ['156', '183'],\n",
       " 7: ['184', '233'],\n",
       " 8: ['163', '180'],\n",
       " 9: ['170', '190', '217']}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lessons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c584c37e",
   "metadata": {},
   "outputs": [],
   "source": [
    "topics = '''Aggregate\n",
    "Ames\n",
    "API\n",
    "Arvo\n",
    "%ask generators\n",
    "Azimuth\n",
    "Behn\n",
    "Clay\n",
    "CLI\n",
    "Dill\n",
    "Distribution\n",
    "Eyre\n",
    "Gall\n",
    "Gall agents\n",
    "Gall (Spider)\n",
    "Hoon\n",
    "Iris\n",
    "Jael\n",
    "Khan\n",
    "Nock\n",
    "Runtime\n",
    "Sail\n",
    "Stdlib\n",
    "Sysadmin\n",
    "Testing'''.split('\\n')\n",
    "\n",
    "# Load and clean CSV of nodes and descriptions.\n",
    "from csv import DictReader\n",
    "\n",
    "nodes = {}\n",
    "edges = {}\n",
    "topicd = {}\n",
    "with open('curr-raw.csv', 'r') as rawFile:\n",
    "    rawData = DictReader(rawFile)\n",
    "    \n",
    "    # Build nodes.\n",
    "    for line in rawData:\n",
    "        if line[\"Topic\"] in ['', 'Aggregate'] or line[\"Competency Cluster\"] in '': continue\n",
    "        nodes[line['#']] = f'{line[\"Topic\"]}: {line[\"Competency Cluster\"]}'\n",
    "        \n",
    "        if line['Antecedents'].strip() == '': continue\n",
    "        edges[line['#']] = []\n",
    "        ants = line['Antecedents'].split(',')\n",
    "        for ante in ants:\n",
    "            if line[\"Antecedents\"].strip() == '0': continue\n",
    "            edges[line['#']].append(ante.strip())\n",
    "            #print(line['#'], edges[line['#']])\n",
    "        \n",
    "        if line[\"Topic\"] in topics:\n",
    "            topic = line['Topic']\n",
    "            if topic == 'Distribution':  topic = 'Clay'\n",
    "            if 'Gall' in topic:  topic = 'Gall'\n",
    "            if 'API' in topic:  topic = 'Stdlib'\n",
    "            if 'CLI' in topic:  topic = 'Khan'\n",
    "            if '%ask' in topic:  topic = 'Hoon'\n",
    "            if 'Sail' in topic:  topic = 'Hoon'\n",
    "            topicd[line[\"#\"]] = topic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eb6d229",
   "metadata": {},
   "source": [
    "##  Mark SVG nodes by topic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3386446a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ames': '#5e4fa2', 'Behn': '#fee08b', 'Clay': '#fdae61', 'Dill': '#66c2a5', 'Eyre': '#f46d43', 'Gall': '#9e0142', 'Iris': '#3288bd', 'Jael': '#d53e4f', 'Khan': '#abdda4', 'Arvo': '#e6f598', 'Hoon': '#9e0142', 'Azimuth': '#d53e4f', 'Nock': '#ffffff', 'Runtime': '#e6f598', 'Stdlib': '#9e0142', 'Sysadmin': '#66c2a5', 'Testing': '#abdda4'}\n"
     ]
    }
   ],
   "source": [
    "# Hoon/Stdlib/API.CLI are solid color\n",
    "# Arvo+vanes are striped\n",
    "\n",
    "colors = [\n",
    "    '#9e0142',\n",
    "    '#d53e4f',\n",
    "    '#f46d43',\n",
    "    '#fdae61',\n",
    "    '#fee08b',\n",
    "    '#e6f598',\n",
    "    '#abdda4',\n",
    "    '#66c2a5',\n",
    "    '#3288bd',\n",
    "    '#5e4fa2',\n",
    "]\n",
    "\n",
    "from numpy.random import choice\n",
    "colors_ = choice(colors, size=(10,), replace=False)\n",
    "colors = {\n",
    "    'Ames':colors_[0],\n",
    "    'Behn':colors_[1],\n",
    "    'Clay':colors_[2],\n",
    "    'Dill':colors_[3],\n",
    "    'Eyre':colors_[4],\n",
    "    'Gall':colors_[5],\n",
    "    'Iris':colors_[6],\n",
    "    'Jael':colors_[7],\n",
    "    'Khan':colors_[8],\n",
    "    'Arvo':colors_[9],\n",
    "    'Hoon':colors_[5],\n",
    "    'Azimuth':colors_[7],\n",
    "    'Nock':'#ffffff',\n",
    "    'Runtime':colors_[9],\n",
    "    'Stdlib':colors_[5],\n",
    "    'Sysadmin':colors_[3],\n",
    "    'Testing':colors_[8],\n",
    "}\n",
    "hatched = ['Ames', 'Behn', 'Clay', 'Dill', 'Eyre', 'Gall', 'Iris', 'Jael', 'Khan', 'Arvo']\n",
    "\n",
    "svg_defs = ''\n",
    "for h in hatched:\n",
    "    svg_defs += f'''<defs><pattern id=\"diagonalHatch{h}\" width=\"4\" height=\"8\" patternTransform=\"rotate(-45 2 2)\" patternUnits=\"userSpaceOnUse\"><path d=\"M -1,2 l 6,0\" stroke=\"{colors[h]}\" stroke-width=\"4\"/></pattern></defs>'''\n",
    "\n",
    "\n",
    "from bs4 import BeautifulSoup\n",
    "import re\n",
    "\n",
    "with open('curr.svg') as f:\n",
    "    svg = f.read()\n",
    "\n",
    "soup = BeautifulSoup(svg, 'lxml')\n",
    "\n",
    "svg_tag = soup.find('svg')\n",
    "svg_grf = svg_tag.find('g')\n",
    "paths = svg_grf.find_all('g', {'class': 'node'})\n",
    "\n",
    "for path in paths:\n",
    "    try:\n",
    "        title = path.findChild('title')\n",
    "    except:\n",
    "        continue\n",
    "    if title.contents[0] in topicd.keys():\n",
    "        ellipse = path.findChild('ellipse')\n",
    "        color = colors[topicd[title.contents[0]]]\n",
    "        ellipse['fill'] = f'{color}'\n",
    "        if topicd[title.contents[0]] in hatched:\n",
    "            ellipse['fill'] = f'url(#diagonalHatch{topicd[title.contents[0]]}) {color}';\n",
    "\n",
    "with open('curr-topics.svg', 'w') as f:\n",
    "    svg = '''<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\\n \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">'''\n",
    "    color = colors['Testing']\n",
    "    svg_str = str(svg_tag)\n",
    "    idx = svg_str.find('<g')\n",
    "    svg_hdr = svg_str[:idx]\n",
    "    svg_str = svg+'\\n'+svg_hdr+svg_defs+'\\n'+svg_str[idx:]\n",
    "    f.write(svg_str)\n",
    "    \n",
    "from cairosvg import svg2png\n",
    "svg2png(bytestring=(svg+str(svg_tag)), dpi=100, write_to='curr-topics.png')\n",
    "\n",
    "print(colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f2396838",
   "metadata": {},
   "outputs": [],
   "source": [
    "svg_str = f'''\n",
    "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\\n \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
    "\n",
    "'''\n",
    "\n",
    "with open('legend.svg', 'w') as f:\n",
    "    svg = ''''''\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e1d2903",
   "metadata": {},
   "source": [
    "# Manually Build App School topics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1a267db3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = '''282,284,\n",
    "382\n",
    "288,299\n",
    "314,330\n",
    "375,482,external\n",
    "200,205,210,215,220,225,230,235,240,245\n",
    "430\n",
    "190,303,217,390'''\n",
    "\n",
    "colors = {\n",
    "    0:'#d31e25',\n",
    "    1:'#d7a32e',\n",
    "    2:'#d1c02b',\n",
    "    3:'#369e4b',\n",
    "    4:'#5db5b7',\n",
    "    5:'#31407b',\n",
    "    6:'#8a3f64',\n",
    "    7:'#4f2e39',\n",
    "}\n",
    "#http://colrd.com/palette/18894/ \"Spectral 10\" by \n",
    "nodes = {}\n",
    "for idx,row in enumerate(data.split('\\n')):\n",
    "    for val in row.split(','):\n",
    "        nodes[val.strip()] = colors[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9ee3b729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After Lesson 0, you should be able to:\n",
      "\n",
      "- Produce a minimalist Gall agent.\n",
      "- Employ the `default-agent` library.\n",
      "- Employ the `%dbug` agent wrapper.\n",
      "- Define entropy and its source.\n",
      "- Utilize `eny` in a random number generator (`og`).\n",
      "- Distinguish insecure hashing (`mug`) from secure hashing (`shax` and friends).\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 1, you should be able to:\n",
      "\n",
      "- Produce an advanced Gall agent without a front-end interface.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 2, you should be able to:\n",
      "\n",
      "- Distinguish dry and wet gates.\n",
      "- Describe use cases for wet gates (using genericity).\n",
      "- Enumerate and distinguish use cases for dry cores (using variance):\n",
      "- - Covariant (`%zinc`)\n",
      "- - Contravariant (`%iron`)\n",
      "- - Bivariant (`%lead`)\n",
      "- - Invariant (`%gold`)\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `|*`\n",
      "- `|@`\n",
      "- `^|`\n",
      "- `^&`\n",
      "- `^?`\n",
      "- `|~`\n",
      "- `|?`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 3, you should be able to:\n",
      "\n",
      "- Diagram how marks convert nouns.\n",
      "- Explain the use of the `++grab`, `++grow`, and `++grad` arms.\n",
      "- Produce a simple mark.\n",
      "- Parse JSON input.\n",
      "- Construct a JSON reparser.\n",
      "- Convert JSON to other formats with a mark.\n",
      "- Retrieve particular values from a JSON input.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `/*`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 4, you should be able to:\n",
      "\n",
      "- Interact with Urbit using Airlock, by language.\n",
      "- Produce an advanced agent with a front-end interface.\n",
      "- Explain the role of a %glob and produce one.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 5, you should be able to:\n",
      "\n",
      "- Explain Arvo as a state machine and event log.\n",
      "- Explain Kelvin versioning and identify the system components that require this approach.\n",
      "- Explain the services Ames provides to the system.\n",
      "- Diagram the architecture of Ames as a network.\n",
      "- Explain the services Behn provides to the system.\n",
      "- Explain the services Clay provides to the system.\n",
      "- Identify key Clay artifacts:  desks, marks, etc.\n",
      "- Explain the services Dill provides to the system.\n",
      "- Explain the services Eyre provides to the system.\n",
      "- Explain the services Gall provides to the system.\n",
      "- Explain the services Iris provides to the system.\n",
      "- Explain the services Jael provides to the system.\n",
      "- Enumerate the secrets Jael tracks.\n",
      "- Explain the services Khan provides to the system.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "- `/?`\n",
      "- `!?`\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 6, you should be able to:\n",
      "\n",
      "- Use Spider to dispatch and manage threads.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "\n",
      "---\n",
      "\n",
      "After Lesson 7, you should be able to:\n",
      "\n",
      "- Run existing unit tests.\n",
      "- Produce a unit test.\n",
      "- Enumerate and identify advanced error messages (`mull-grow`, etc.).\n",
      "- Produce a desk suitable for distribution (with a docket file).\n",
      "- Install and distribute software.\n",
      "- Explain elements of a docket file.\n",
      "- Set up a continuous integration pipeline to test Gall agents and other published code.\n",
      "\n",
      "You will know the runes:\n",
      "\n",
      "\n",
      "---\n",
      "\n"
     ]
    }
   ],
   "source": [
    "data = '''282,284\n",
    "382\n",
    "288,299\n",
    "314,330\n",
    "375,482,external\n",
    "200,205,210,215,220,225,230,235,240,245\n",
    "430\n",
    "190,303,217,390'''\n",
    "\n",
    "lessons = {}\n",
    "for idx,row in enumerate(data.split('\\n')):\n",
    "    lessons[idx] = []\n",
    "    for val in row.split(','):\n",
    "        lessons[idx].append(val.strip())\n",
    "\n",
    "import yaml\n",
    "for lesson in lessons:\n",
    "    print(f'After Lesson {lesson}, you should be able to:\\n')\n",
    "    for node in lessons[lesson]:\n",
    "        # whatever your local path is\n",
    "        fname = f'/home/neal/urbit/curriculum/lessons/{node}.yml'\n",
    "        try:\n",
    "            with open(fname, 'r') as f:\n",
    "                data = f.read()\n",
    "            data = yaml.safe_load(data)\n",
    "        except:\n",
    "            continue\n",
    "            \n",
    "        for obj in data['objectives']:\n",
    "            print('-', obj)\n",
    "    \n",
    "    print('\\nYou will know the runes:\\n')\n",
    "    for node in lessons[lesson]:\n",
    "        # whatever your local path is\n",
    "        fname = f'/home/neal/urbit/curriculum/lessons/{node}.yml'\n",
    "        try:\n",
    "            with open(fname, 'r') as f:\n",
    "                data = f.read()\n",
    "            data = yaml.safe_load(data)\n",
    "        except:\n",
    "            continue\n",
    "            \n",
    "        for rune in data['runes']:\n",
    "            print(f'- `{rune}`')\n",
    "    print('\\n---\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca3b67f1",
   "metadata": {},
   "source": [
    "# Mark SVG nodes by color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7f752235",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here\n"
     ]
    }
   ],
   "source": [
    "from bs4 import BeautifulSoup\n",
    "import re\n",
    "\n",
    "with open('curr.svg') as f:\n",
    "    svg = f.read()\n",
    "\n",
    "soup = BeautifulSoup(svg, 'lxml')\n",
    "\n",
    "svg_tag = soup.find('svg')\n",
    "svg_grf = svg_tag.find('g')\n",
    "paths = svg_grf.find_all('g', {'class': 'node'})\n",
    "\n",
    "for path in paths:\n",
    "    try:\n",
    "        title = path.findChild('title')\n",
    "    except:\n",
    "        continue\n",
    "    if title.contents[0] in nodes:\n",
    "        ellipse = path.findChild('ellipse')\n",
    "        color = nodes[title.contents[0]]\n",
    "        ellipse['fill'] = f'{color}'\n",
    "        if title.contents[0] == '217':\n",
    "            print('here')\n",
    "            #style=\"fill: url(#circles-1) #fff;\"\n",
    "            ellipse['fill'] = f'url(#diagonalHatch) {color}';\n",
    "            pass\n",
    "\n",
    "with open('curr-asl.svg', 'w') as f:\n",
    "    svg = '''<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\\n \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">'''\n",
    "    color = colors[0]\n",
    "    svg_str = str(svg_tag)\n",
    "    idx = svg_str.find('<g')\n",
    "    svg_hdr = svg_str[:idx]\n",
    "    svg_defs = f'''<defs><pattern id=\"diagonalHatch\" width=\"4\" height=\"8\" patternTransform=\"rotate(-45 2 2)\" patternUnits=\"userSpaceOnUse\"><path d=\"M -1,2 l 6,0\" stroke=\"{color}\" stroke-width=\"4\"/></pattern></defs>'''\n",
    "    svg_str = svg+'\\n'+svg_hdr+svg_defs+'\\n'+svg_str[idx:]\n",
    "    f.write(svg_str)\n",
    "    \n",
    "from cairosvg import svg2png\n",
    "svg2png(bytestring=(svg+str(svg_tag)), dpi=100, write_to='curr-asl.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9bb9967",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a48dd4f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}