Infinite Mac is a collection of classic Macintosh and NeXT system releases and software, all easily accessible from the comfort of a web browser.

Particularly cool is the support for running (early versions of) BeOS in the browser!

An overview of object capabilities, an access-control mechanism that composes nicely and has sensible behaviour, unlike ACLs/RBAC. Uses everyday examples to explain capabilities themselves as well as the notion of attenuation of authority. Also includes a discussion of practical considerations.

An insane amazing hack, placing the structured information normally contained in ELF executable files into a SQLite database and then registering SQLite databases with the kernel as executables and writing a special linker/loader to instantiate a process directly from the database file.

As one wit put it on lobste.rs, “The children yearn for proper database and record primitives in their OS instead of having to have it in a library.”

Edited to add: A follow-up post extends the idea to allow programs to store their own state in their executable’s database! Single executables then serve as both program and (transactional, relational) data set.

Low-level implementation details on how Fil-C, a memory-safe, capability-oriented C compiler and runtime, is able to implement function calls efficiently while maintaining strong, well-defined memory-safety invariants:

Fil-C achieves memory safety even for programs that behave adversarially. That includes casting function pointers to the wrong signature and then calling them, exporting a function with one signature in one module and then importing it with a different signature in another, or even exporting a symbol as a function in one module and importing it as data in another (and vice-versa). Passing too few arguments, arguments of the wrong type, misusing va_list (including escaping it), expecting too many values to be returned - these are all things that the Fil-C calling convention either catches with a panic or ascribes safe behavior to.

Part 2 of a three-part essay, “The Interfaces With Which We Think” (the third part of which has yet to appear). Argues for the importance of malleable user interfaces: that people should be able to compose and customise their digital tools, not just consume them as fixed products.

A person should be allowed to adapt their interfaces no less than they should be allowed to think.

A cool recent Smalltalk VM based directly on Smalltalk-80 and closely following the classic “Blue Book” design, but somewhat modernized and implemented in Rust. Straighforward and understandable.

Bret Victor’s Dynamicland project. I love this and want to build one myself. There is SO MUCH content and so many fascinating ideas here: Dynamicland reimagines computing as a physical, collaborative, malleable, humane medium. The website is itself constructed using Dynamicland and contains a wealth of videos, papers, and other documentation.

Arcan is an alternative approach to display servers and UI, drawing inspiration from object capabilities, Plan 9, malleability and much more. See also the 12 Principles for a Diverging Desktop Future blog post for an overview.

Squeak is a direct descendant of the Smalltalk-80 system. Lots to criticise, lots to be inspired by. One of my favourite operating systems, one of my favourite programming languages! Not that it couldn’t be better, of course…

An accessible and informal discussion of threat modeling, with examples. See also the Threat Modeling Manifesto.

Part of the S6 cinematic universe: a set of simple, powerful system scripting tools that offer alternatives to traditional shell scripting and init systems. The execline language is a chain-loading command execution tool with careful semantics around variable expansion and block management. Interesting as a kind of embedded DSL in the Unix scripting tradition.

A recent microkernel design from Bunnie Huang and collaborators. Not a Unix-like; instead, a microkernel, broadly inspired by QNX, but presumably also drawing on modern securable microkernels like seL4.

A recent stab at “personal cloud” network management.

Our mission is to make sure peer-to-peer, user-controlled, community software can beat Big Tech solutions. That’s why we’re working on platform fundamentals that would open the way for our FOSS stack to match the usability and convenience of proprietary platforms.

Pretends a local machine’s containers are a little LAN, exposing that LAN to a browser (via a custom SOCKS proxy) to form a hyperlinkable namespace:

We have Ptyxis as a container-aware terminal emulator… why isn’t there a container-aware web browser that would just communicate directly with the containers? […] As the title suggests, now there kinda is a container-aware browser.

A rigorous approach to threat modelling. Well, more rigorous than Soatok’s Informal Guide to Threat Models, anyway. Documents the values, principles, and key characteristics of threat modelling as an industry practice. Covers patterns, anti-patterns, and overall philosophy.

Arcan is an alternative approach to display servers and UI, drawing inspiration from object capabilities, Plan 9, malleability and much more. This blog post motivates and gives an overview of the project; see also the main project page.

An excellent paper that skewers the common cultural understanding of the C programming language as being a “low-level” or “portable assembly” language. Modern CPUs have diverged so far from the C abstract machine that C no longer provides predictable “close-to-the-metal” guarantees.

Avery Pennarun (one of the original authors of Tailscale) summarises the state-of-the-art wisdom with respect to network queue management. Bookmark this to come back to when you need it.

How big should your queue be, and what should you do when it fills up? Many times, we implement or even deploy a networking system before we have answered those questions. Luckily, recent research has given us some guidelines. Here’s what we know: […]

An examination of several approaches to handling overload, flow-control, and backoff, with examples drawn from Erlang/OTP programming.

[…] there is a rich zoo of overload problems and potential solutions […] ranging far beyond a simple queue boundary for mailboxes. By reasoning and looking at your system, it becomes interesting to figure out which approach is best: a small system with some relatively infrequent load-spikes may be fine with a queue or a pull-based mechanism. An all-synchronous system may be fine with simple counter-based protection for most tricky cases. […]

The OOPSLA 1997 paper that introduced Squeak, a Smalltalk implementation “written in itself”:

Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks.

The paper discusses the bootstrapping process, the VM’s object format and garbage collector, the Smalltalk-subset-to-C translation process, the implementations’ approach to the BitBlt graphics primitive, performance, and the fledgling Squeak community. The latter is still going strong thirty-some years later.