Steven Wittens' personal site. The content itself is good — essays on math, graphics, and visualization — but the real point is how it's built. Every post is an interactive, animated explanation. This is what it looks like when someone takes "show don't tell" seriously in a technical context. Pay attention to how he uses WebGL to make abstract math tangible. When you're building interfaces for Shrubbery, this is the bar for making complex systems legible.
Ngnghm (pronounced "Houyhnhnm," from Gulliver's Travels) is a blog exploring what computing should look like if we threw away our assumptions and started over. Written by François-René Rideau (Fare), it covers live systems, capability security, first-class namespaces, and more. The essays are dense but worth it — they articulate many of the same frustrations with current computing that Shrubbery is designed to address. Read the pieces on first-class implementations and orthogonal persistence especially.
https://github.com/VictorTaelin
Taelin is building HVM (Higher-order Virtual Machine), a massively parallel functional runtime based on interaction nets. The key insight is that optimal lambda calculus reduction is inherently parallel — you don't bolt concurrency onto a sequential model, you start with a model where parallelism falls out naturally. This connects to Shrubbery's approach of making concurrency fundamental rather than an afterthought. Look at how HVM handles sharing and duplication of data through interaction combinators.
https://web.cs.wpi.edu/~jshutt/kernel.html Full dissertation: https://digitalcommons.wpi.edu/etd-dissertations/375/
Shutt's thesis argues that fexprs — combiners that receive their operands unevaluated — are more primitive than lambda, and that the problems historically associated with fexprs were actually caused by dynamic scoping, not by fexprs themselves. His language Kernel splits lambda into two orthogonal pieces: $vau (the operative, which doesn't evaluate its operands) and wrap (which adds evaluation). This is relevant to Shrubbery because it's about finding the minimal, correct primitive abstractions and building everything else from composition rather than special cases.
https://archive.org/details/smbx-genera-programming-env-1987/mode/1up
This is the manual for the Symbolics Lisp Machine development environment. Genera represents the high-water mark of integrated, self-modifying programming environments — the entire system, from device drivers to the window manager, was written in Lisp and inspectable/modifiable at runtime. The system construction tool, the patch system, the network-transparent namespaces, the "world" model — all of this is relevant context for understanding what Shrubbery is trying to recapture in a modern, distributed setting. Notice how the boundaries between "OS," "IDE," and "application" don't really exist.
By Gregor Kiczales, Jim des Rivières, Daniel G. Bobrow
AMOP describes CLOS (the Common Lisp Object System) and, more importantly, its metaobject protocol — the idea that the language's own object system is itself made of objects that you can override and extend. This is the definitive treatment of computational reflection done right. The MOP lets you change how method dispatch works, how inheritance resolves, how slot access behaves — all from within the language itself. For Shrubbery, this is the philosophical ancestor of making the system's own mechanisms first-class and user-modifiable.
By Doug Hoyte https://letoverlambda.com/
An advanced Lisp book focused on closures and macros. The title refers to the pattern of a let binding over a lambda — a closure — which Hoyte argues is the fundamental unit of abstraction in Lisp. The book goes deep on macro writing techniques, reader macros, and the power of treating code as data. Relevant for understanding how Lisp's homoiconicity enables the kind of metaprogramming that most languages can't touch, and why the fexpr paper matters.
https://9p.io/sys/man/ Also: https://plan9.io/plan9/
Plan 9 is the OS that should have replaced Unix. Its core idea: everything is a file, and everything is a namespace. Each process gets its own namespace that can be composed from different file servers. Network resources, device drivers, and system services are all accessed through the same filesystem interface. The namespace-per-process model is the most direct ancestor of Shrubbery's namespace architecture. Read the intro docs and Rob Pike's talks — especially "The Name Game" — to understand the why.
CHM deep history: https://computerhistory.org/blog/the-deep-history-of-your-apps-steve-jobs-nextstep-and-early-object-oriented-programming/ Hansen Hsu's history: https://medium.com/chmcore/a-short-history-of-objective-c-aff9d2bde8dd Original NeXT ObjC manual (1993): http://www.bitsavers.org/pdf/next/Release_3_Nov93/Object-Oriented_Programming_and_the_Objective_C_Language_Release_3_Jul93.pdf
NeXTSTEP showed what happens when you build an entire operating system and development environment around Smalltalk-style message passing (via Objective-C) with a real GUI toolkit. Interface Builder, the AppKit, the Responder Chain — these design patterns are still the foundation of Apple's platforms decades later. The key lesson: good abstractions compound over time. Also relevant because Tim Berners-Lee built the first web browser on NeXTSTEP, and the "NS" prefix in Apple's APIs (NSObject, NSString) literally stands for NeXTSTEP.
https://solidproject.org/ Technical spec: https://solidproject.org/about
Solid (Social Linked Data) is Tim Berners-Lee's project to re-decentralize the web. Users store their data in "Pods" (personal online data stores), and applications request access to specific data rather than hoarding it in their own silos. The core idea — separating data ownership from application logic — is directly relevant to Shrubbery's model where the namespace is the source of truth and applications are just views into it. Note both where Solid gets it right (data sovereignty, user control) and where it struggles (adoption, developer experience, the RDF dependency).
http://conal.net/papers/icfp97/
The original FRP paper. Elliott and Hudak introduce "behaviors" (time-varying values) and "events" (discrete occurrences) as the two fundamental primitives for reactive systems. This is the intellectual ancestor of Shrubbery's Vine model — the idea that values flow through a dependency graph and updates propagate automatically. Understanding FRP will make the reactive layer of Shrubbery click immediately. Read this before trying to understand Vines.
https://erlang.org/download/armstrong_thesis_2003.pdf
"Making reliable distributed systems in the presence of software errors." Armstrong's thesis is the best articulation of why process isolation, message passing, and "let it crash" philosophy produce systems that actually work in the real world. Written after 20 years of building telecom systems at Ericsson. The budget/timeout mechanism in Shrubbery's actor model rhymes with Erlang's supervision trees. Readable, practical, no unnecessary math. The chapter on Concurrency Oriented Programming is essential.
Inventing on Principle: https://vimeo.com/36579366 Future of Programming: https://vimeo.com/71278954
Victor's talks are about closing the feedback loop between creator and creation. "Inventing on Principle" argues that creators need immediate connection to what they're making. "The Future of Programming" is a devastating critique of how the field stopped exploring fundamental ideas after the 1970s. Both talks articulate the experience Shrubbery is trying to create — a system where you can see and feel the effects of your changes in real time, not one where you write text and hope.
http://erights.org/ Dissertation: http://erights.org/talks/thesis/markm-thesis.pdf
Mark Miller's work on the E language and object-capability security. The core insight: if you can only interact with objects you hold references to, and references can only be obtained by being given them, then the reference graph is the access control graph. No ACLs, no ambient authority — just objects and references. This is directly relevant to how Shrubbery's namespace handles permissions and authority. Without understanding ocaps, the security model will seem arbitrary. With ocaps, it becomes obvious.
Final report (2012): http://www.vpri.org/pdf/tr2012001_steps.pdf First year report: http://www.vpri.org/pdf/tr2007008_steps.pdf Original proposal: http://www.vpri.org/pdf/NSF_prop_RN-2006-002.pdf
Kay's Viewpoints Research Institute asked: can you build an entire personal computing system — OS, networking, graphics, applications — in 20,000 lines of code instead of millions? The answer was "almost." The approach: build domain-specific languages for each layer, compose them, and let meaning drive implementation. The philosophical alignment with Shrubbery is deep — both projects reject the idea that software complexity is inevitable and seek radical compression through better abstractions.
https://lamport.azurewebsites.net/pubs/time-clocks.pdf
The foundational paper on logical time in distributed systems. Lamport shows that in a distributed system, there is no single "now" — only a partial ordering of events established by message passing. If Ian is going to understand why Shrubbery makes the distributed tradeoffs it does, they need to understand what the tradeoffs are. This paper is short, clear, and changes how you think about time and causality in networked systems.
http://www.shenlanguage.org/ Kernel page: https://web.cs.wpi.edu/~jshutt/kernel.html
Shen is a functional language with a sequent calculus type system and a tiny kernel (Kλ) of ~46 primitive functions. The entire language — pattern matching, type system, macros — compiles to this minimal core. Given that the fexpr paper is already on the list, Shen is the natural companion: it's another approach to the "small kernel, big expressiveness" problem, but with a radically different type system. The Kλ portability story (implement 46 functions, get the whole language) is relevant to Shrubbery's own portability goals.