#+TITLE: No Ideas, but in Things

"No ideas, but in things" -- by William Carlos Williams expresses an
idea around learning that's only recently crystallized in my head.

I'm an auto-didact; most of what I know about programming is
self-taught. One of the biggest challenges I face as a self-taught
programmer is to gauge the depth of understanding I've built on a
subject. Do I actually understand things, or just think I do?

Learning about both the Dunning-Kruger effect and impostor syndrome
hasn't helped in the least: how do I distinguish between the two?

I have to admit that I don't believe most college exams -- or MOOC
assignments and tests -- meaningfully measure understanding beyond a
very superficial level [fn:questions]. Looking backwards at attempts
at learning: android, systems programming, neural networks, databases,
programming languages... the knowledge that's stuck around in my head
is the knowledge that I directly applied and built something with. 

Which brings me to the point of this note: I only trust that I've
mastered a topic once I can apply it to build something tangible.[fn:tangible]

Accordingly, here's a list of projects I'm over-optimistically
planning to work on over the next several years to feel reasonably
competent as a programmer (along with some resources as I accumulate
them over time).

This is obviously incomplete, and also very loosely structured; I'll
prioritize based on what complements my professional work, and simply
follow my nose on other occasions. 

The idea is to build something more robust than a toy, but not necessarily
something optimized for millions of computers and performance. I'll
open source parts of these, write about them in others; and possibly
simply publish the end products of the rest.

* Algorithms, Data Structures, Automata, etc.
- Implement BTree
- Implement a CRDT
- Implement a regular expression engine.
- Implement a SAT Solver.
- Implement an RTree
- Implement Purely Functional Data Structures
- Implement Prof. Erik Demaine's advanced data structures
  
* Databases
- Implement a Log-structured Key-value DB.
- Implement a SQL DB.

* AI, ML & Statistics
- Implement a neural network from scratch.
- Implement learning algorithms from scratch.
- Test these out in real projects that help in my daily life.
  
* Programming Languages, Virtual Machines, etc.
- Implement a Scheme interpreter and compiler.
  - An incremental approach to compiler construction
- Implement a Virtual machine for a lisp.
- Implement a Garbage Collector.
- Implement a Type-Checker.
- Contribute to Python.
- Contribute to Rust.

* Systems, networking, etc.
- Implement a production web server.
- Implement a complete operating system.
- Write my own shell.
- Implement a Simulator.
- Re-implement suckless software:
  - dwm
  - dmenu
  - st
- Standard networking tools from scratch:
  - dig
  - tcpdump
  - ping, ping6
- Implement some utilities
  - rsync
- Contribute to the Linux Kernel.

* Graphics, rendering, etc.
- Raytracer 
  - Raytracing in one weekend
- Image rendering, manipulation
  - PNG renderer
  - JPEG renderer
- Image manipulation

* Tools / software
- Debugger powered tracers. (currently active)
- A web browser
- Implement a text editor.
  - No prizes for guessing the inspiration.
- Factorio blueprint designer (presumably with the SAT solver)

* History
- 2020-07-12: Copied over my accumulated list so far.

[fn:questions] It's extremely hard to make a question paper that makes
a student truly engage with a subject and test his understanding; I'm
grateful for Professors who made those exams and still remember
them. Particularly Prof. G. V. Ramana, taught Geotechnical
Engineering, and Prof. Ashok Gupta, who taught Structural Engineering.

[fn:tangible] This works out better for programming projects because
the finished result either works; or doesn't. It's somewhat harder for
english and writing, but is still better than simply reading through
several books and assuming competence.