actually add the tags, oops

blog/FTL.md

@@ -3,6 +3,7 @@ title: FTL tips
 description: We are not responsible if these tips cause your ship to implode/explode. Contains spoilers in vast quantities.
 created: 16/08/2017
 updated: 08/03/2020
+tags: ["fiction", "games"]
 ---
 * Use Cloaking *after* enemy weapons have fired so that they miss.
 * Upgrade Shields as soon as possible; many early-sector enemies can't get through 2 shields.

blog/abstract-concept-georgism.md

@@ -3,6 +3,7 @@ title: "A modest proposal: Abstract Concept Georgism"
 description: Generalize land value tax to short names.
 created: 27/03/2025
 slug: georg
+tags: ["economics"]
 ---
 ::: epigraph attribution="Ancient American curse"
 May your markets be efficient.

blog/ai-accelerator.md

@@ -4,6 +4,7 @@ description: "Or: why most AI hardware startups are lying."
 slug: accel
 created: 06/10/2024
 katex: true
+tags: ["hardware", "ai"]
 ---
 ::: epigraph attribution=Chlorokin
 Except in the domain of making near-omnipotent computer entities, I project very little progress in the next 50 years.

blog/ar-glasses.md

@@ -3,6 +3,7 @@ title: Consumer AR glasses
 description: Why I think they're not popular, and what they need.
 created: 22/03/2025
 slug: glass
+tags: ["hardware", "hci"]
 ---
 ::: epigraph attribution="Daniel Eliot Boese"
 What were you expecting? At one point, the solution to all communication issues was a handheld glassy rectangle. Welcome to the future. We do things differently here.

blog/autocrafting-algorithms.md

@@ -123,7 +123,7 @@ This is not very efficient - it globally optimizes over the whole relevant subtr
 
 The problem is still not over. For one thing, the solver ignores cycles, where recipes (indirectly) contain themselves, because it can't topologically sort them, though you could likely adapt it quite easily since the ILP side doesn't care about order. More importantly, as an [AE2 developer describes](https://www.reddit.com/r/feedthebeast/comments/7t8v0o/autocrafting_is_npcomplete/dtbgkz9/), when there are multiple ways to make something there are subjective tradeoffs to make: is it better to consume slightly fewer items but use more machine time? What if avoiding extra machine time consumes an expensive resource? What if a large job is running and, without consuming this item, the user will have to wait tens of minutes? Since the algorithm I describe is ILP-based, it admits and indeed requires an objective function (where a SAT-based one wouldn't) - in my code, it minimizes crafting steps, but it could be replaced with one which cares about time and resource consumption. However, while it could use this information, it doesn't have it.
 
-We can easily imagine tracking the time taken to run a recipe on a machine automatically, and perhaps having a "priority" switch to bump lower-priority jobs and switch to faster operations, but it can't easily know how valued an input is (though several heuristics are plausible), and many, such as power draw (or sometimes fluid inputs), are not known as part of crafting patterns (they could in principle be added, but this would be inconvenient). AE2 "solves" this by having users manually configure every recipe they want to use, but this is a large time sink and does not solve the problem in cases where users do actually want to use multiple recipes in different circumstances.
+We can easily imagine tracking the time taken to run a recipe on a machine automatically, and perhaps having a "priority" switch to bump lower-priority jobs and switch to faster operations, but can't easily automatically know how valued an input is (though several heuristics are plausible), and many, such as power draw (or sometimes fluid inputs), are not known as part of crafting patterns (they could in principle be added, but this would be inconvenient). AE2 "solves" this by having users manually configure every recipe they want to use, but this is a large time sink and does not solve the problem in cases where users do actually want to use multiple recipes in different circumstances.
 
 There is a further issue: randomness. Sometimes - mostly with "raw material" operations such as pulverizing ores or growing crops - outputs are produced nondeterministically some fraction of the time. This makes exact forward planning of recipe execution completely impossible, though in principle you could assume, say, the 95th percentile cost and rerun the random part until it works. In practice, most people run these as part of "always-on" systems which build up stockpiles (e.g. [this](https://guide.appliedenergistics.org/1.20.4/example-setups/recursive-crafting-setup)), or assume that the recipe will run enough as part of deterministic queries.
 

blog/barracuda-f380b.md

@@ -3,6 +3,7 @@ title: Linux on the Barracuda CloudGen Firewall F380 Revision B
 description: My new main router.
 created: 10/02/2025
 slug: f380b
+tags: ["hardware", "own tech", "linux"]
 ---
 While idly browsing eBay, I came across Barracuda Networks "firewall" devices, mysterious boxes with lots of (fairly low-speed) network IO and basic general-purpose-computer IO (USB and VGA). It transpired that Barracuda is primarily in the business of selling expensive software licenses to people who for some reason don't want to use open-source software, and that the mysterious boxes were actually rebadged x86 machines from various "network appliance" vendors. The [F180A](https://campus.barracuda.com/product/cloudgenfirewall/doc/169426005/f180-and-f183-revision-a) I was considering originally has an outdated Atom CPU[^1] and apparently an integrated WiFi card, which was not very interesting, but further searching turned up the [F380B](https://campus.barracuda.com/product/cloudgenfirewall/doc/93880710/f380-revision-b/) at a very low price (£37). Barracuda do not document this, but as far as I can tell it's actually an [Aewin SCB-1723](https://www.aewin.com/products/scb-1723/), with "recent" (2017) Intel CPU compatibility[^2] and a low-end Celeron in it - and, in their version, two SFP+ ports driven by an [X710](https://www.intel.com/content/www/us/en/products/details/ethernet/700-network-adapters/x710-network-adapters/docs.html)! I clearly had to get one to stop my overtaxed access point from also serving as a router.
 

blog/bitter-algebra.md

@@ -3,6 +3,7 @@ title: Bitter-lesson computer algebra
 description: Computer algebra systems leave lots to the user and require task-specific manual design. Can we do better?
 slug: bitalg
 created: 09/01/2025
+tags: ["maths", "ai"]
 ---
 ::: epigraph attribution=Viliam link="https://www.astralcodexten.com/p/are-woo-non-responders-defective/comment/16746415"
 Who does math these days anyway? If you keep saying it, GPT-5 will learn it as a fact, and if someone asks it to design an ancestor simulation, it will include it among its rules.
@@ -18,7 +19,7 @@ There is a well-developed [theory](https://en.wikipedia.org/wiki/Confluence_(abs
 
 If a natural heuristic isn't available, we must simply create one, by using deep learning to approximate the functions we wish we could have. The approach used to significant success in [AlphaProof](https://deepmind.google/discover/blog/ai-solves-imo-problems-at-silver-medal-level/) is, according to the scant public descriptions, based on [AlphaZero](https://arxiv.org/abs/1712.01815). It works over formal proofs (in [Lean](https://lean-lang.org/)) rather than expression rewrites, and bootstraps a policy neural net (which generates a distribution over next steps) and value neural net (which rates probability of success) by using <span class="hoverdefn" title="Monte Carlo Tree Search">MCTS</span> to "amplify" the policy. This was, apparently, quite computationally expensive, and is perhaps not very practical for cheap home use. However, our potential design space is broader than this.
 
-Lean is a complex and heavy programming language, so executing a Lean program is expensive compared to neural net forward passes, so AlphaProof has to use a relatively large neural net to match up inference time and proof validation time[^4]. This may not be true of a well-written symbolic expression manipulator. There's a clever and little-known program called [RIES](https://www.mrob.com/pub/ries/index.html), which finds equations given their solutions (the opposite of a normal numerical evaluator). Using caching (roughly) and a heavily optimized expression generator/evaluator which essentially brute-forces short [RPN](https://en.wikipedia.org/wiki/Reverse_Polish_notation) programs sorted by complexity, it can generate and evaluate several billion expressions a second (and differentiate top candidates). While a flexible pattern matcher would have to be slower, it is likely possible to outperform a standard CAS with explicit design for performance and externalization of ease-of-use features. Larger-scale search with a worse neural-net heuristic trades expensive GPU time for cheaper CPU time and might still be competitive, as StockFish is in chess versus more heavily neural-net-driven engines like [LC0](https://lczero.org/) (though this is down to properties of chess's search trees and is not, to my knowledge, true in e.g. Go).
+Lean is a complex and heavy programming language, so executing a Lean program is expensive compared to neural net forward passes, so AlphaProof has to use a relatively large neural net to match up inference time and proof validation time[^4]. This may not be true of a well-written symbolic expression manipulator. There's a clever and little-known program called [RIES](https://www.mrob.com/pub/ries/index.html), which finds equations given their solutions (the opposite of a normal numerical evaluator). Using caching (roughly) and a heavily optimized expression generator/evaluator which essentially brute-forces short [RPN](https://en.wikipedia.org/wiki/Reverse_Polish_notation) programs sorted by complexity, it can generate and evaluate several ~~billion~~ tens of millions of expressions a second (and differentiate top candidates). While a flexible pattern matcher would have to be slower, it is likely possible to outperform a standard CAS with explicit design for performance and externalization of ease-of-use features. Larger-scale search with a worse neural-net heuristic trades expensive GPU time for cheaper CPU time and might still be competitive, as StockFish is in chess versus more heavily neural-net-driven engines like [LC0](https://lczero.org/) (though this is down to properties of chess's search trees and is not, to my knowledge, true in e.g. Go).
 
 There has also been some work in the other direction - more neural net use and less search. [Deep Learning for Symbolic Mathematics](https://arxiv.org/abs/1912.01412) trains standard sequence-to-sequence models to do integration and solve ODEs with apparently good results (compared with traditional computer algebra systems). However, it relies on external methods to generate good training datsets (e.g. for integrals, differentiating random expressions and integration by parts). [PatternBoost](https://arxiv.org/abs/2411.00566) constructs extremal objects by repeatedly retraining an autoregressive model on the best of its outputs augmented with greedy search, and was good enough to solve an open problem despite little compute, somewhat cursed tokenization, and treating the problem as unconditionally sampling from "reasonably good" examples. Some [recent work in reinforcement learning](https://arxiv.org/abs/2408.05804) has also demonstrated directed exploration emerging from a simple contrastive algorithm which could be useful - PatternBoost-style construction could be reformulated as an RL problem amenable to this[^5], and a contrastive goal expression/current-expression-and-rule encoder is almost exactly the necessary distance heuristic I mentioned earlier.
 

blog/heavenbanning-economics.md

@@ -4,6 +4,7 @@ description: Predicting the post-social world.
 created: 26/01/2025
 slug: heaven
 squiggle: true
+tags: ["ai", "economics"]
 ---
 ::: epigraph attribution=Architects link="https://www.youtube.com/watch?v=nT9NUjeBocw"
 Delete another day <br />

blog/maghammer.md

@@ -6,6 +6,7 @@ description: Powerful search tools as externalized cognition, and how mine work.
 slug: maghammer
 series: maghammer
 series_index: 1
+tags: ["own tech", "ai", "search"]
 ---
 ::: epigraph attribution="Deus Ex"
 The need to be observed and understood was once satisfied by God. Now we can implement the same functionality with data-mining algorithms.

blog/maghammer2.md

@@ -6,6 +6,7 @@ description: I got annoyed and rewrote everything.
 slug: maghammer2
 series: maghammer
 series_index: 2
+tags: ["own tech", "ai", "search"]
 ---
 ::: epigraph attribution=RossM
 If Google Search does not return the result the user wanted because the user typed the wrong thing in the search box, that is a failure on Google's part, not a failure on the user's part. Conversely, if Google Search does return the result the user wanted because the user typed the correct thing in the search box, that is a failure on Google's part, not a failure on the user's part.

blog/magic.md

@@ -3,6 +3,7 @@ title: Thoughts on fictional magic systems
 description: What exactly is "magic" anyway?
 slug: magic
 created: 12/05/2024
+tags: ["fiction"]
 ---
 ::: epigraph author=Unknown
 Arcane magical rituals work because they are adversarial inputs on AI controlling all of reality.
@@ -20,7 +21,7 @@ I did allude to the fact that I intended to write this at some point, and now I
 
 Now that I've forced you to read those paragraphs, my real position is that "magic" is a fuzzy aesthetic concept related to all of these things to varying degrees: for any "technology" I can think of, I can adjust some surface details and/or backstory to make it "magic", and vice versa. At some level, people generally don't like the way science, technology and the real world work, since our default ontologies aren't built for them, and we have some standard ways to imply "I'm ignoring these in favour something I like more".
 
-The way more or less every magic system, including "hard" ones, leaves its operations massively underspecified, provides some interesting worldbuilding opportunities. I initially thought of this while reading [a book](https://www.goodreads.com/en/book/show/51279226) with a rune-based magic system in which the simplest spell is a "source-link", built out of three runes (~8 bits each[^3]) and yet with many degrees of freedom already filled in - it's targeted using some kind of raycasting (but subject to gravity), renders as a green line, and performs several operations dependent on what the user is thinking[^4]. However, the problem of where the details come from is applicable to almost everything and, I think, infrequently explicitly addressed[^5] ([Ra](https://qntm.org/ra) is significantly about this, and some obscure [HPMoR](https://hpmor.com/) authors' notes talk about it). Here are some possible approaches:
+The way more or less every magic system, including "hard" ones, leaves its operations massively underspecified provides some interesting worldbuilding opportunities. I initially thought of this while reading [a book](https://www.goodreads.com/en/book/show/51279226) with a rune-based magic system in which the simplest spell is a "source-link", built out of three runes (~8 bits each[^3]) and yet with many degrees of freedom already filled in - it's targeted using some kind of raycasting (but subject to gravity), renders as a green line, and performs several operations dependent on what the user is thinking[^4]. However, the problem of where the details come from is applicable to almost everything and, I think, infrequently explicitly addressed[^5] ([Ra](https://qntm.org/ra) is significantly about this, and some obscure [HPMoR](https://hpmor.com/) authors' notes talk about it). Here are some possible approaches:
 
 1. Spellcasters *do* have to specify almost everything (well, down to moderately complex physics), possibly making magic a way to internalize what would otherwise take lots of machinery. This is roughly the approach in [Ra](https://qntm.org/ra) and [The Machineries of Empire](https://www.goodreads.com/book/show/26118426-ninefox-gambit). Characters are legally required to offhandedly mention arbitrarily complex mathematics.
 2. The less you specify the more power is required, presumably to derive the remainder some other way. I haven't seen anything but [Break Them All](https://forums.sufficientvelocity.com/threads/break-them-all-original-precross.12960/) (an obscure unfinished prequel (?) to a fanfiction to a webserial) do this. This provides a fairly natural way to make magic users more powerful from study, and to make advance preparation useful.
@@ -40,7 +41,7 @@ This is more of a set of somewhat linked ramblings than a cohesive post like I u
 
 [^3]: Possibly a few extra for position.
 
-[^4]: This is actually not a great example: it's not as complicated as some other "simple" things in other fiction, and the spell-complexity issue is explicitly called out later in reference to a cleaning spell.
+[^4]: This is not a great example: it's not as complicated as some other "simple" things in other fiction, and the spell-complexity issue is explicitly called out later in reference to a cleaning spell.
 
 [^5]: I think this is because authors frequently study English and not ~~a real subject~~ sciences.
 

blog/meme-thresher.md

@@ -5,6 +5,7 @@ slug: memethresher
 created: 22/04/2024
 series: meme_search
 series_index: 1
+tags: ["own tech", "ai", "search", "memes"]
 ---
 ::: epigraph attribution=AI_WAIFU
 I think what you need to do is spend a day in the data labeling mines.

blog/memesae.md

@@ -4,6 +4,7 @@ description: As ever, AI safety becomes AI capabilities.
 created: 06/10/2024
 series: meme_search
 series_index: 2
+tags: ["own tech", "ai", "search", "memes"]
 ---
 ::: epigraph attribution=@revhowardarson link=https://twitter.com/revhowardarson/status/1830464099396010402
 The fact that you can build a chatbot out of a statistical abstract of all human language is among the least interesting things about a statistical abstract of all human language.

blog/minecraft-power-creep.md

@@ -3,6 +3,7 @@ title: Modded Minecraft power creep trends
 description: Has Minecraft become easier?
 created: 01/11/2024
 slug: mcpower
+tags: ["fiction", "games"]
 ---
 Playing modded Minecraft, I have the vague impression that many things have been simplified over the years of development. Of course, vague impressions from memory aren't very reliable, so I've gathered slightly more robust information by looking at what general-purpose "kitchen sink" modpacks in various versions had available. The categories I will use are by nature somewhat arbitrary, but I think they're good enough to be useful. If you don't want to know about all the details, [skip to the conclusion](#conclusion).
 
@@ -105,7 +106,7 @@ You can reasonably argue that it's not an actual problem because multiplayer gam
 
 Something to note here is that we don't see a smooth monotonic progression towards more power. There generally instead seems to be convergence toward a "preferred" level of simplicity/abstraction/power within each domain, progressing rapidly at first as people discover-or-invent new mechanics and occasionally reversing (e.g. Create, AE2[^9]). There's also lots of sensitivity to the actions and design goals of individual developers, making jumps discontinuous and somewhat unpredictable. It also appears that power creep is avoidable by individual mod authors by deliberately reducing interconnectivity with other mods, such that users cannot pick-and-choose optimal solutions finely, and by having unusual features which can't clearly be compared in power[^7].
 
-What can we learn from this outside of Minecraft mod balance? Probably not that much. While we see that the dynamics involved have been quite sensitive to individual developers, I think this is because there's not very strong selection pressure on mods and because "generations" are slow rather than this being a more general pattern. One interesting angle here is that the (apparent) nonexistence of a dominant strategy often comes from the advantages and disadvantages being merely hard to compare rather than actually equal. I think this holds up in other contexts, and growing ability to make end-to-end comparisons might remove illusions that many things are equally matched.
+What can we learn from this outside of Minecraft mod balance? Probably not that much. While we see that the dynamics involved have been quite sensitive to individual developers, I think this is because there's not very strong selection pressure on mods and because "generations" are slow rather than this being a more general pattern. One interesting angle here is that the (apparent) nonexistence of a dominant strategy often comes from the advantages and disadvantages being merely hard to compare rather than truly equal. I think this holds up in other contexts, and growing ability to make end-to-end comparisons might remove illusions that many things are equally matched.
 
 [^1]: In a way, this is similar to (the ideal of) cloud computing.
 

blog/minoteaur.md

@@ -3,6 +3,7 @@ title: Minoteaur
 description: The history of the feared note-taking application.
 created: 06/06/2023
 updated: 28/08/2023
+tags: ["own tech"]
 ---
 ::: epigraph attribution=@visakanv link=https://twitter.com/visakanv/status/1775741429392039946
 The goal is to have smart walkable high-density mixed-use note systems.
@@ -10,46 +11,46 @@ The goal is to have smart walkable high-density mixed-use note systems.
 
 If you've talked to me, you've probably heard of Minoteaur.
 It was conceptualized in 2019, when I determined that it was a good idea to take notes on things in a structured way, looked at all existing software, and was (as usual, since all software is terrible; I will probably write about this at some point) vaguely unsatisifed by it.
-I don't actually remember the exact details, since I don't have notes on this which I can find, but this was around the time when Roam Research leaked into the tech noösphere, and I was interested in and generally agreed with the ideas of graph-structured note-taking applications, with easy and fast flat organization.
+I don't remember the exact details, since I don't have notes on this which I can find, but this was around the time when Roam Research leaked into the tech noösphere, and I was interested in and generally agreed with the ideas of graph-structured note-taking applications, with easy and fast flat organization.
 However, Roam itself was (is) closed-source SaaS and thus obviously unsuitable for personal notes, and made weird technical decisions I didn't like, as did the best available alternative (TiddlyWiki with various plugins I read about).
 Most software also didn't seem to care about data durability or revision history, which is important to me, since notes are less useful if you can't rely on their future availability.
 Thus, Minoteaur: I would just write something myself to my very specific requirements and preferences, with all the features I needed and none I didn't.
-This did not actually go as planned.
+This did not go as planned.
 
 ## The rewrite treadmill
 
 While the exact history of Minoteaur is lost to overly sparse notes on it, the lack of publicly released development versions, and my lack of documentation, the rough outline is fairly clear.
 An early mostly-server-rendered [Node.js/PostgreSQL version](https://github.com/osmarks/minoteaur) (Minoteaur 1) was written in early 2019, with very basic features: you could edit pages, categorize them, link to them, view revisions and even highlight syntax for no particularly good reason.
 Being designed as a single-user system, it was deliberately designed with basically no security, and I had some fun on the public instance I had up sometimes as a demo with self-replicating viral pages.
-As usually happens with sufficiently large projects which I can't neatly complete in pieces, I got bored of actually working on this, especially since useful changes would have required a big rewrite.
+As usually happens with sufficiently large projects which I can't neatly complete in pieces, I got bored of working on this, especially since useful changes would have required a big rewrite.
 It did, at least, get away with supporting its capabilities using impressively little code.
 While wrong people believe that better software involves more code, I, as an enlightened programmer, recognize that you should write as little code as possible, as more code means more bugs *and* more work to write and maintain it.
 
 ::: captioned src=/assets/images/minoteaur_1_1.png
-Self-replicating Minoteaur pages on the legacy public Minoteaur. I can no longer actually get it to run, so I don't have any other images.
+Self-replicating Minoteaur pages on the legacy public Minoteaur. I can no longer get it to run, so I don't have any other images.
 :::
 
-After deciding that I really did need something which actually worked even if it wasn't perfect, I settled on... installing [DokuWiki](https://www.dokuwiki.org/dokuwiki) - while a PHP application and not particularly modern featurewise, it was known to be robust, supported *most* of what I wanted, and basically worked.
+After deciding that I really did need something which worked even if it wasn't perfect, I settled on... installing [DokuWiki](https://www.dokuwiki.org/dokuwiki) - while a PHP application and not particularly modern featurewise, it was known to be robust, supported *most* of what I wanted, and basically worked.
 I even dabbled in the horrors of PHP to make some tweaks and plugins I wanted work.[^1]
 
 However, the dream of Minoteaur had not yet died.
 Prototypes were developed and reengineered for new, exciting Minoteaurs based on Node.js, SQLite3 and single-page application technologies, to implement a more TiddlyWiki-like UI with multiple pages open at once and offer generally better interactivity.
-Unfortunately, despite the nicer interface and actually-useful Markdown preview mode, these proved frustrating to work on, due to the usual difficulties of maintaining consistency between client code with persistent state and a server which also has persistent state, and I ultimately consigned Minoteaur 2 and 3 to the depths of my project folder in mid-2020.
+Unfortunately, despite the nicer interface and useful Markdown preview mode, these proved frustrating to work on, due to the usual difficulties of maintaining consistency between client code with persistent state and a server which also has persistent state, and I ultimately consigned Minoteaur 2 and 3 to the depths of my project folder in mid-2020.
 It was also somewhat slow, due to the overhead of parsing Markdown into a parse tree and then rendering that parse tree to virtual DOM and then rendering virtual DOM to actual DOM nodes.
 
 ::: captioned src=/assets/images/minoteaur_2.png
 Minoteaur 2's multitasking UI was ultimately abandoned in favour of just using native browser tabs or windows.
 :::
 
-While researching for this I thought that Minoteaur 4 didn't actually exist because of accidents with the numbering scheme, but it turns out that it does, but it's actually Minoteaur 1.5.
-I had vague memories of a prototype Rust backend for use with a single-page application (with a vaguely RESTful API rather than the usual tightly-coupled RPC designs I use) which I had assumed was developed after the Node.js ones, but it was actually made significantly before those in late 2019.
+While researching for this I thought that Minoteaur 4 didn't exist because of accidents with the numbering scheme, but it turns out that it does, but it's really Minoteaur 1.5.
+I had vague memories of a prototype Rust backend for use with a single-page application (with a vaguely RESTful API rather than the usual tightly-coupled RPC designs I use) which I had assumed was developed after the Node.js ones, but it was made significantly before those in late 2019.
 I presumably mostly forgot about it because it wasn't very good or useful.
 This was still the early days of Rust's use in web things, so it used synchronous IO, a version of `warp` so early that some of the filters had silly names like `post2` or `get2` to maintain some semblance of backwards compatibility, and Diesel.
 I also apparently never wrote a client to go with it, so I'm not really sure how it was meant to work.
 
 Minoteaur 5 does assuredly exist, and it was developed later in 2020.
 Rust having advanced somewhat since the days of Minoteaur 4, it uses asynchronous IO libraries, and switches back to server-rendering with `maud` HTML templates.
-It "mostly worked" at the level of Minoteaur 1, but also proved annoying to work on, especially since the Markdown parsing mechanisms are quite annoying (none of the Markdown parsing libraries are particularly easy to *extend*, but `pulldown-cmark` returns an event stream, so I had to write some somewhat terrible code to streamingly process that and count up `[`s and `]`s, which actually then got rewritten to only *partly* do the weird streaming parsing and to mostly hand it off to regexes).
+It "mostly worked" at the level of Minoteaur 1, but also proved annoying to work on, especially since the Markdown parsing mechanisms are quite annoying (none of the Markdown parsing libraries are particularly easy to *extend*, but `pulldown-cmark` returns an event stream, so I had to write some somewhat terrible code to streamingly process that and count up `[`s and `]`s, which then got rewritten to only *partly* do the weird streaming parsing and to mostly hand it off to regexes).
 
 When I got sufficiently annoyed by that again, I rewrote it in Nim for [Minoteaur 6](https://git.osmarks.net/osmarks/minoteaur).
 Nim is sort of how I would design a programming language, both in the sense that it makes a lot of nice decisions I agree with (extensive metaprogramming, style insensitivity) and in that it's somewhat quirky and I don't understand why some things happen (particularly with memory management, for which it has seemingly several different incompatible systems which can be switched between at compile time[^2]).
@@ -70,9 +71,9 @@ Python is my go-to language for rapid prototyping, i.e. writing poor-quality cod
 Minoteaur 7 was a short-lived variant using server rendering, which was rapidly replaced by Minoteaur 7.1, which used a frontend web framework called Svelte for its UI[^3].
 It contained many significant departures from all previous Minoteaurs, mostly for the better: notably, it finally incorporated indirection for pages.
 While all previous implementations had just stored pages under their (somewhat normalized) title, I decided that not structuring it that way would be advantageous in order to allow pages to be renamed and referred to by multiple names, so instead pages have a unique, fixed ID and several switchable names.
-This introduced the minor quirk that all Markdown parsing and rendering was done on the backend, which was not really how I'd usually do things but did actually make a good deal of the code simpler (since it is necessary to parse things there to generate plaintext for search).
-As a search mechanism, I also (since Python made this actually practical) used deep-learning-based semantic search (using [Sentence Transformers](https://www.sbert.net/)) rather than the term-based mechanisms in SQLite.
-This was actually quite easy to do thanks to the hard work of library developers, although I did write my own in-memory vector index for no clear reason, and frequently worked quite well (surfacing relevant content even if it didn't contain the right keywords) but with some unreliability (keyword matches were not always found).
+This introduced the minor quirk that all Markdown parsing and rendering was done on the backend, which was not really how I'd usually do things but did make a good deal of the code simpler (since it is necessary to parse things there to generate plaintext for search).
+As a search mechanism, I also (since Python made this practical) used deep-learning-based semantic search (using [Sentence Transformers](https://www.sbert.net/)) rather than the term-based mechanisms in SQLite.
+This was quite easy to do thanks to the hard work of library developers, although I did write my own in-memory vector index for no clear reason, and frequently worked quite well (surfacing relevant content even if it didn't contain the right keywords) but with some unreliability (keyword matches were not always found).
 It also got the furthest yet in terms of general usability, mostly because I implemented file upload, which I think is necessary for any useful notes software (you do, at the very least, want to be able to add and reference images).
 Ultimately, for some reason I forgot (I think mostly database management this time), I decided that I disliked the code and rewrote it yet again, leading to Minoteaur 8.
 
@@ -87,7 +88,7 @@ An earlier prototype displaying its search capabilities.
 Since notes aren't really *that* big, I worked out that even under pessimistic assumptions the RAM requirements would be lower than those of the JS/Python interpreter processes running previous Minoteaurs, which were not particularly large anyway (more on this in my future writing on how all software is terrible), and this made a lot of the code simpler due to not having to limit data structures to what SQLite supports and not having to deal with async IO for read operations.
 
 Despite considerable success in making it work to the same extent as previous Minoteaurs (files, search, backlinks, Markdown, etc) and even somewhat further (nicer Markdown syntax, and a three-pane UI), development was mysteriously halted for a while in March and nonmysteriously (some inconsistencies in how context for backlinks versus for search worked which felt annoying to fix) in July after I picked it back up.
-This April, I happened to look again for some reason, and found that the problem was actually easy if reframed slightly, then did everything else I wanted for usability parity with my DokuWiki install over the course of three days, wrote an import and DokuWiki migration script, redid some of the syntax for more reliable parsing, and finally transitioned away from DokuWiki after slightly less than 4 years.
+This April, I happened to look again for some reason, and found that the problem was in fact easy if reframed slightly, then did everything else I wanted for usability parity with my DokuWiki install over the course of three days, wrote an import and DokuWiki migration script, redid some of the syntax for more reliable parsing, and finally transitioned away from DokuWiki after slightly less than 4 years.
 
 ::: captioned src=/assets/images/minoteaur_8.png
 Minoteaur's Minoteaur page.
@@ -96,11 +97,11 @@ Minoteaur's Minoteaur page.
 To allow discovery of interesting content you may have forgotten, Minoteaur incorporates a random pages list.
 :::
 
-## So what does it actually do?
+## So what does it do?
 
 It's described somewhere as a "wiki-styled graph-structured personal note-taking application", and this is basically correct, as I would hope, because I wrote that.
 It's the intersection of what I wanted and what I could be bothered to build in the domain of notes.
-Despite significant inspiration from things like Roam and TiddlyWiki, I don't actually implement their particularly unique and special features (the strong focus on the graph and the block structure of Roam, and the metaprogrammability/LISPness of TiddlyWiki), because they seem excessive and I don't actually care - in the spirit of the Pareto principle, most of the value to me comes from relatively basic features.
+Despite significant inspiration from things like Roam and TiddlyWiki, I don't implement their particularly unique and special features (the strong focus on the graph and the block structure of Roam, and the metaprogrammability/LISPness of TiddlyWiki), because they seem excessive and I don't particularly care - in the spirit of the Pareto principle, most of the value to me comes from relatively basic features.
 It can, however:
 
 * view, store and search pages.
@@ -116,7 +117,7 @@ It can, however:
 * run JS on the serverside as part of Markdown processing, in lieu of a plugin API (I had to ship the interpreter anyway for KaTeX).
 * associate structured data (text or numbers) with pages, and run queries based on that.
 
-Should you actually use it?
+Should you use it?
 Probably not: while it works reliably enough for me, this is because I am accustomed to its strangeness and deliberately designed it to my requirements rather than anyone else's, sometimes in ways which are very hard to change now (for example, adding things like pen drawings would be really hard structurally, and while there was a Minoteaur 8 prototype with a different architecture which would have made that easier, it was worse to write most code for so I didn't go ahead with that), and can rewrite and debug it easily enough if I have to.
 Other people cannot.
 I am not writing this in order to convince people to switch over (that would create support requests) but to provide context and show off my technical achievement, such as it is.
@@ -126,10 +127,10 @@ I am not writing this in order to convince people to switch over (that would cre
 While it works as-is, mostly, active real-world use has given me ideas about how it could be better.
 ~~At this time, I'm mostly interested in improving the search mechanism to include phrase queries, negative queries and exact match queries, better integration with external tools (for example, with some engineering effort I could move Anki card specifications into notes and not have to maintain that separately), and a structured data mechanism for attaching machine-readable content to pages.~~
 
-I actually did add some of these. The search mechanism does now allow "exact" and "negative" queries, although it still has some brokenness I intend to fix at some point, and there's a fully featured structured data mechanism. Pages can have a list of key/value pairs attached (numeric or textual) and can then be queried by those using a few operators in the search.
+I ultimately did add some of these. The search mechanism does now allow "exact" and "negative" queries, although it still has some brokenness I intend to fix at some point, and there's a fully featured structured data mechanism. Pages can have a list of key/value pairs attached (numeric or textual) and can then be queried by those using a few operators in the search.
 
 [^1]: I think this was just nice syntax for superscript/subscript formatting which I ultimately realized could just be replaced by TeX, and some ugly hacks to stop it complaining when I upgraded to PHP 8.
 
 [^2]: Apparently it [standardized on](https://nim-lang.org/docs/mm.html) reference counting with cycle detection now.
 
-[^3]: I use this for most new projects now. It's very pleasant to use, and apparently quite fast, which I value to some extent.
+[^3]: I use this for most new projects now. It's very pleasant to use, and apparently quite fast, which I value to some extent.

blog/ml-workstation.md

@@ -4,6 +4,7 @@ description: How to run local AI slightly more cheaply than with a prebuilt syst
 created: 25/02/2024
 updated: 02/02/2025
 slug: mlrig
+tags: ["hardware", "ai"]
 ---
 ::: emphasis
 
@@ -51,7 +52,7 @@ It may look innocent, but it is a menace to unaware hobbyists.
 
 ### Do not buy workstation cards
 
-Nvidia has a range of workstation graphics cards. However, they are generally worse than their consumer GPU counterparts in every way except for VRAM capacity, sometimes compactness, and artificial feature gating (PCIe P2P and ECC): the prices are drastically higher (the confusingly named RTX 6000 Ada Generation ("6000A") sells for about four times the price of the similar RTX 4090), the memory bandwidth lower (consumer cards use GDDR6X, which generally offers higher bandwidth, but workstation hardware uses plain GDDR6 due to power) and performance in practice actually worse even when on paper it should be better. The 6000A has an underpowered cooler and aggressively throttles back under high-power loads, resulting in drastically lower performance.[^11]
+Nvidia has a range of workstation graphics cards. However, they are generally worse than their consumer GPU counterparts in every way except for VRAM capacity, sometimes compactness, and artificial feature gating (PCIe P2P and ECC): the prices are drastically higher (the confusingly named RTX 6000 Ada Generation ("6000A") sells for about four times the price of the similar RTX 4090), the memory bandwidth lower (consumer cards use GDDR6X, which generally offers higher bandwidth, but workstation hardware uses plain GDDR6 due to power) and performance in practice worse even when on paper it should be better. The 6000A has an underpowered cooler and aggressively throttles back under high-power loads, resulting in drastically lower performance.[^11]
 
 ### Workload characteristics
 
@@ -96,7 +97,7 @@ Also note that modern GPUs are very big. You should be sure that your case suppo
 
 ### CPU inference
 
-While I don't like this myself, you might be interested in slowly running very large language models interactively and nothing else. This is when datacentre GPUs might actually be sane (still not K80s), as well as running on CPU. To a first approximation, one token generated requires two FLOPS (one fused multiply-add) per parameter regardless of quantization, and loading every weight into cache from RAM once. Here is (roughly) the compute and memory bandwidth available with various hardware:
+While I don't like this myself, you might be interested in slowly running very large language models interactively and nothing else. This is when datacentre GPUs might, for once, be sane (still not K80s), as well as running on CPU. To a first approximation, one token generated requires two FLOPS (one fused multiply-add) per parameter regardless of quantization, and loading every weight into cache from RAM once. Here is (roughly) the compute and memory bandwidth available with various hardware:
 
 <div class="wider">
 
@@ -154,7 +155,7 @@ They describe somewhat horrifying electrical engineering problems due to using s
 
 [^10]: See the "PSUs" section [here](https://nonint.com/2022/05/30/my-deep-learning-rig/).
 
-[^11]: I don't seem to actually have a source for this (probably old Discord conversations), but I'm obviously right.
+[^11]: I don't seem to have a source for this (probably old Discord conversations), but I'm obviously right.
 
 [^12]: Meaning optimized code for a specific computing task, not *OS* kernels.
 

blog/new-website.md

@@ -2,9 +2,10 @@
 title: New site design!
 created: 25/01/2020
 description: It's slightly different now!
+tags: ["own tech"]
 ---
 If you visit this frequently (why would you?) you may have noticed that since late last year there's been a page notifying you of service disruption and no actual content any more.
 This is because the old code used to generate the HTML files making up the site was a several-year-old and somewhat flaky Haskell program, and I've been meaning to replace it for a while, but finally got round to it recently after quite a while of just leaving the service disruption page up.
 
 This new site design should be somewhat easier for me to work on, has some extra features I wanted, comes with a nice new style, and should still allow most of the features you're used to to work.
-The service worker for caching is much better (actually works properly now), so you can also use it offline to some extent!
+The service worker for caching is much better (actually works properly now), so you can also use it offline to some extent!

blog/not-everyone-must-code.md

@@ -4,10 +4,11 @@ description: Why I think that government programs telling everyone to "code" are
 slug: nemc
 updated: 09/02/2020
 created: 14/08/2018
+tags: ["education", "opinion"]
 ---
 Imagine that some politician said "Cars are an important part of our modern economy. Many jobs involve cars. Therefore, all students must learn how to build cars; we will be adding it to the curriculum."
 This does (to me, anyway) seem pretty ridiculous on its own.
-*Now* imagine that the students are being taught to make small car models out of card, whilst being told that this is actually how it's always done (this sort of falls apart, since with the car thing it's easy for the average person to tell; most people can't really distinguish these things with programming).
+*Now* imagine that the students are being taught to make small car models out of card, whilst being told that this is how it's always done (this sort of falls apart, since with the car thing it's easy for the average person to tell; most people can't really distinguish these things with programming).
 This is what the push to "learn to code" in schools (this was written in 2017, when the UK's government was making a big thing of this, but it still seems to be going on now, in 2020) seems like to me.
 In fact, it's even worse, with hyperbolic claims of it being "the new literacy", often made by people who have never done anything beyond basic block-dragging in Scratch or some equivalent.
 
@@ -17,21 +18,21 @@ Most of the "learn to code" resources, especially those done in schools, start w
 This is fine for learning a few basic things (though not very good - Scratch's weird programming environment maps poorly onto actual widely-used languages), but there doesn't seem to be anything beyond that taught most of the time - it's considered "too hard" for the students involved, usually, or there just isn't anyone qualified to teach it.
 And that basic dragging around of blocks is not hugely useful - it doesn't teach much (*maybe* basic concepts of flow control), and you may have to *un*learn things when moving to actual programming.
 
-I have an alternative list of things to teach which I think might actually be relevant and helpful to people in a way that making a cat dance on screen by blindly following a tutorial is not:
+I have an alternative list of things to teach which I think might be relevant and helpful to people in a way that making a cat dance on screen by blindly following a tutorial is not:
 
 * an introduction to computer hardware (for troubleshooting, etc) and what all the myriad cables do
 * basics of networking (what routers do, ISPs and their job, one of those layered network models, HTTP(S), DNS)
 * privacy in the digital age (i.e. maybe stop giving Facebook/Google/Amazon all your private information)
 * operating systems, what various programs are for, and the fact that ones which *aren't Windows* exist
 * what programming involes
-* basic shell-or-equivalent scripting (though this may not actually be very useful either, as the OSes people mostly interact with now - iOS, Windows, Android, etc. - disallow this sort of thing or don't make it very useful, sadly)
+* basic shell-or-equivalent scripting (though this may not be very useful either, as the OSes people mostly interact with now - iOS, Windows, Android, etc. - disallow this sort of thing or don't make it very useful, sadly)
 * fixing basic problems using advanced IT techniques such as "using a search engine to look up your issue" and "blindly tweaking settings until it does something"
 
 This doesn't really sound as fancy as teaching "the new literacy", but it seems like a better place to start for helping people be able to interact with modern computer systems.
 
 ## Update (2020-02-09)
 
-Having shown someone this post, they've suggested to me that Scratch is more about teaching some level of computational thinking-type skills - learning how to express intentions in a structured way and being precise/specific - than actually teaching *programming*, regardless of how it's marketed.
+Having shown someone this post, they've suggested to me that Scratch is more about teaching some level of computational thinking-type skills - learning how to express intentions in a structured way and being precise/specific - than teaching programming *per se*, regardless of how it's marketed.
 This does seem pretty sensible, actually.
 I can agree that it is probably useful for this, since most people will enjoy making visual things with direct feedback than writing a bunch of code to print "Hello, World!" or sort a list or something.
 Still, it definitely does have limits for this given that it's quite lacking in control flow capability and abstraction compared to regular programming languages.

blog/on-phones.md

@@ -4,6 +4,7 @@ description: My (probably unpopular in general but... actually likely fairly pop
 slug: phones
 created: 01/06/2018
 updated: 24/01/2020
+tags: ["opinion", "hardware"]
 ---
 * Why notches? WHY? Just because Apple used them doesn't mean every single manufacturer needs to start making their screens have ugly black bits on them.
 * Really, why Apple at all? They sell uncustomisable and locked-down stuff at higher and higher prices with fewer and fewer nice-to-haves (e.g. headphone jacks) each year. And the vendor lock-in (Lightning headphones, iVersionsOfMostOtherSoftware) is also bad.

blog/online-safety-bill.md

@@ -4,12 +4,13 @@ description: In which I get annoyed at yet more misguided UK government behaviou
 created: 08/07/2021
 updated: 19/08/2021
 slug: osbill
+tags: ["politics", "opinion"]
 ---
 ::: epigraph attribution="Malcolm Turnbull"
 The laws of Australia prevail in Australia, I can assure you of that. The laws of mathematics are very commendable, but the only law that applies in Australia is the law of Australia.
 :::
 
-I recently found out that the UK government aims to introduce the "[Online Safety Bill](https://www.gov.uk/government/publications/draft-online-safety-bill)" and read about it somewhat (no, I have not actually read much of the (draft) bill itself; it is 145 pages with 146 of impact assessments and 123 of explanatory notes, and so out of reach of all but very dedicated lawyers) and, as someone on the internet, it seems very harmful. This has already been detailed quite extensively and probably better than I [can](https://techcrunch.com/2021/05/12/uk-publishes-draft-online-safety-bill/) [manage](https://www.openrightsgroup.org/blog/access-denied-service-blocking-in-the-online-safety-bill/) [elsewhere](https://matrix.org/blog/2021/05/19/how-the-u-ks-online-safety-bill-threatens-matrix), so I'll just summarize my issues relatively quickly. 
+I recently found out that the UK government aims to introduce the "[Online Safety Bill](https://www.gov.uk/government/publications/draft-online-safety-bill)" and read about it somewhat (no, I have not actually read much of the (draft) bill itself; it is 145 pages with 146 of impact assessments and 123 of explanatory notes, and so out of reach of all but very dedicated lawyers) and, as someone on the internet, it seems very harmful. This has already been detailed quite extensively and probably better than I [can](https://techcrunch.com/2021/05/12/uk-publishes-draft-online-safety-bill/) [manage](https://www.openrightsgroup.org/blog/access-denied-service-blocking-in-the-online-safety-bill/) [elsewhere](https://matrix.org/blog/2021/05/19/how-the-u-ks-online-safety-bill-threatens-matrix), so I'll just summarize my issues relatively quickly.
 
 Firstly, it appears to impose an unreasonable amount of requirements on essentially every internet service (technically mine, too, due to the comments box!): risk-assessments, probably age verification (age is somewhat sensitive information which it would not be good for all websites to have to collect), fees for companies of some size (I think this is just set by OFCOM), and, more generally, removing "harmful content", on pain of being blocked/sanctioned/fined. Not *illegal* content, just "content that is harmful to children/adults" (as defined on page 50 or so). The bill is claimed to deal with the excesses of Facebook and other large companies, and they certainly have problems, but this affects much more than that (and doesn't seem to address their main problems (misaligned incentives with users causing optimization for engagement over all else, privacy violations, monopolistic behaviour) much).
 
@@ -25,4 +26,4 @@ Update (19/07/2021): also consider reading [this](https://boingboing.net/2012/01
 
 Update (06/08/2021): [Oh look, Apple just did the client-side scanning thing](https://appleprivacyletter.com/). I do not think this sets a good precedent; this is the most obviously defensible usecase for this technology, and now future extensions can just be portrayed as a natural extension of it. The best case is that this is a prelude to E2EE iCloud, but this is still a fundamental hole in the security of such a thing. Whatever happens, given government pressure, reverting this will be quite hard.
 
-Update (19/08/2021): As it turns out, NeuralHash, which Apple intend to use for the above, is [easily collidable](https://github.com/anishathalye/neural-hash-collider) (using a fairly generic technique which should be applicable to any other neural-network-based implementation). This seems like something which should have been caught prior to release. And apparently it has [significant variations](https://github.com/AsuharietYgvar/AppleNeuralHash2ONNX) from floating point looseness, somehow. The "1 in 1 trillion" false positive rate is maybe not very likely. It [is claimed](https://www.theverge.com/2021/8/18/22630439/apple-csam-neuralhash-collision-vulnerability-flaw-cryptography) that this is not a significant issue primarily because the hashes are secret (because of course); however, this still creates a possible issues for the system, like editing the hash of an actually-bad image to avoid detection, or (with this and some way to get around the later review stages, like [adverserial image scaling](https://bdtechtalks.com/2020/08/03/machine-learning-adversarial-image-scaling/) or just [using legal content likely to trigger a human false-positive](https://news.ycombinator.com/item?id=28238071)) generating otherwise okay-looking images which are flagged. Also, the [Apple announcement](https://www.apple.com/child-safety/) explicitly says "These efforts will evolve and expand over time", which is a worrying thing I did not notice before.
+Update (19/08/2021): As it turns out, NeuralHash, which Apple intend to use for the above, is [easily collidable](https://github.com/anishathalye/neural-hash-collider) (using a fairly generic technique which should be applicable to any other neural-network-based implementation). This seems like something which should have been caught prior to release. And apparently it has [significant variations](https://github.com/AsuharietYgvar/AppleNeuralHash2ONNX) from floating point looseness, somehow. The "1 in 1 trillion" false positive rate is maybe not very likely. It [is claimed](https://www.theverge.com/2021/8/18/22630439/apple-csam-neuralhash-collision-vulnerability-flaw-cryptography) that this is not a significant issue primarily because the hashes are secret (because of course); however, this still creates a possible issues for the system, like editing the hash of an actually-bad image to avoid detection, or (with this and some way to get around the later review stages, like [adverserial image scaling](https://bdtechtalks.com/2020/08/03/machine-learning-adversarial-image-scaling/) or just [using legal content likely to trigger a human false-positive](https://news.ycombinator.com/item?id=28238071)) generating otherwise okay-looking images which are flagged. Also, the [Apple announcement](https://www.apple.com/child-safety/) explicitly says "These efforts will evolve and expand over time", which is a worrying thing I did not notice before.

blog/other-stuff.md

@@ -4,6 +4,7 @@ description: A nonexhaustive list of media which I like and which you may also b
 created: 11/06/2020
 updated: 17/09/2024
 slug: otherstuff
+tags: ["fiction", "opinion"]
 ---
 I'm excluding music from this because music preferences seem to be even more varied between the people I interact with than other preferences.
 Obviously this is just material *I* like; you might not like it, which isn't really my concern - this list is primarily made to bring to people's attention media they might like but have not heard of.
@@ -221,7 +222,7 @@ And so the frog says... 'Because you're a scorpion.'
 
 [Theft of Fire](https://www.goodreads.com/book/show/199142773-theft-of-fire): I am very conflicted on this, but I did like it enough to fast-track it and read it in two days, so I am including it. Expanding on this might deserve an entire blog post, but it would be a short blog post, and this would create odd incentives unless I expand all other entries to blog posts, which I won't.
 
-It is "hard scifi" in the sense of The Expanse (moderately recently) and lots of older fiction (it's been compared to Heinlein, who I haven't actually read much) - spacefaring technology and a few peripheral areas advance substantially, and most other technologies are unchanged, as opposed to e.g. The Quantum Thief where everything is radically overhauled to the limits of known physical laws. I can generally accept this as a setting conceit like I accept fantasy worlds, but it feels strange to be 200 years in the future and have neural interfaces but only used for primitive AR, computers nominally thousands of times more powerful but with capabilities slightly worse than 2024's state of the art[^3], and spaceships maintained with modern-era manually-operated machine tools. This does, at least, make the problem-solving more relatable to us modern people. It portrays spaceflight under the constraints of astrodynamics and having to not pulp your human crew very well. The governance of the (off-Earth parts of the) setting is apparently anarchocapitalist, which is a minor detail I bring up because it caused me to discover that there's a [Libertarian Futurist Society](https://www.lfs.org/) with a very 90s-but-in-a-good-way website.
+It is "hard scifi" in the sense of The Expanse (moderately recently) and lots of older fiction (it's been compared to Heinlein, who I haven't actually read much) - spacefaring technology and a few peripheral areas advance substantially, and most other technologies are unchanged, as opposed to e.g. [The Quantum Thief](#the-quantum-thief) where everything is radically overhauled to the limits of known physical laws. I can generally accept this as a setting conceit like I accept fantasy worlds, but it feels strange to be 200 years in the future and have neural interfaces but only used for primitive AR, computers nominally thousands of times more powerful but with capabilities slightly worse than 2024's state of the art[^3], and spaceships maintained with modern-era manually-operated machine tools. This does, at least, make the problem-solving more relatable to us modern people. It portrays spaceflight under the constraints of astrodynamics and having to not pulp your human crew very well. The governance of the (off-Earth parts of the) setting is apparently anarchocapitalist, which is a minor detail I bring up because it caused me to discover that there's a [Libertarian Futurist Society](https://www.lfs.org/) with a very 90s-but-in-a-good-way website.
 
 It is very character-driven, in the sense that the main characters being silly drives most of the plot. Some of the characterization is odd, though it has its moments of brilliance. The author clearly wants to distinguish the "space roughneck" main character Marcus from "space princess" Miranda, but this is done oddly. I cannot believe that he simultaneously knows what Dirac monopoles are, has read enough Lewis Carroll to say "typical Lewis Carroll" in first-person internal monologue, and was apparently a childhood scifi fan, but doesn't know what "Fibonacci" and "anthropomorphizing" mean. Miranda is described as very intelligent; the author does not entirely ignore this as some might have, but the fact that she should be able to resolve most of their situation with about ten minutes of internet access (which she has) is not noticed.
 
@@ -259,7 +260,7 @@ The author, Zachary Mason, also wrote [The Lost Books of the Odyssey](https://ww
 
 ### We Are Legion (We Are Bob)
 
-[We Are Legion (We Are Bob)](https://www.goodreads.com/book/show/32109569-we-are-legion-we-are-bob) by Dennis E. Taylor is a fun and decent, though not particularly deep or smart[^5], space-colonization science fiction story.
+[We Are Legion (We Are Bob)](https://www.goodreads.com/book/show/32109569-we-are-legion-we-are-bob) by Dennis E. Taylor is a fun and decent, though not particularly deep or smart[^5], vaguely transhuman space-colonization science fiction story. It has a bizarrely simplified universe in many ways: faster-than-light communication with no relativity worries, near-universally-biocompatible life, mentally humanlike aliens and present but nonthreatening AI.
 
 ### Short stories
 
@@ -289,6 +290,7 @@ The author, Zachary Mason, also wrote [The Lost Books of the Odyssey](https://ww
 * [Shannon's Law](https://web.archive.org/web/20140628065855/http://www.tor.com/stories/2011/05/shannons-law).
 * [Dave Scum](https://docs.google.com/document/d/1SddGHeVfcVa5SCDHHTOA4RlKwnef-Q6IMw_Jqw9I0Mw/mobilebasic).
 * [Nate the Snake](https://natethesnake.com/) is a complex setup for a pun.
+* [Instruments of Destruction](https://alexanderwales.com/instruments-of-destruction/).
 * More to be added when I feel like it.
 
 ## Games
@@ -321,6 +323,10 @@ This is actually two separate series (the [British](https://en.wikipedia.org/wik
 
 [Limitless](https://en.wikipedia.org/wiki/Limitless_(TV_series)) (the movie is also decent) is among the somewhat less bad fictional depictions of superhuman intelligence, but mostly a good comedy. Unfortunately, like many of the series I like, it was killed unreasonably early. Perhaps future AI technology will simply predict the next season.
 
+### Margin Call
+
+[Margin Call](https://en.wikipedia.org/wiki/Margin_Call) is the best (2008) financial crisis movie. Understated, character-driven in a good way and smart.
+
 ### Pantheon
 
 [Pantheon](https://en.wikipedia.org/wiki/Pantheon_(TV_series)) was saved from cancellation and unwatchability (which was apparently done for nonsense tax reasons) by Amazon, though I believe it's still nontrivial to watch.
@@ -341,7 +347,11 @@ Men have gazed at the stars for millennia, and wondered whether there was a deit
 
 ### Travelers
 
-[Travelers](https://en.wikipedia.org/wiki/Travelers_(TV_series)) contains a novel (to me, at least) take on time travel. Some of it is somewhat dumb, and the ending is clearly very rushed, but the idea is quite new and it's otherwise well-executed.
+[Travelers](https://en.wikipedia.org/wiki/Travelers_(TV_series)) contains a novel (to me, at least) take on time travel. Some of it is somewhat dumb, and the ending is clearly very rushed, but the idea is quite new and it's otherwise fairly well-executed.
+
+### Upload
+
+[Upload](https://en.wikipedia.org/wiki/Upload_(TV_series)) is one of the other TV series I've seen on the subject of brain uploads. It's set in a world where this is relatively normalized, so there's much less of the philosophical hand-wringing I find annoying, and while mostly a comedy it retains internal consistency and some sense of stakes.
 
 ## Other
 

blog/political-opinions.md

@@ -4,6 +4,7 @@ description: This is, of course, all part of my evil plan to drive site activity
 created: 24/09/2023
 updated: 15/01/2024
 slug: opinion
+tags: ["politics", "opinion"]
 ---
 ::: epigraph attribution=pyrartha
 If you aren't slandering those who disagree even slightly with you at every opportunity and talking about how you want to beat them up, do you even hold any political beliefs?
@@ -11,7 +12,7 @@ If you aren't slandering those who disagree even slightly with you at every oppo
 
 This may sound strange coming from someone whose website contains things which are clearly [political opinions](/osbill/); I am being [hypocritical](https://www.overcomingbias.com/p/homo-hipocritushtml)/didn't notice/have updated my views since that/am writing hyperbolically or ironically to make a point/do not require myself to have self-consistent beliefs (select your favourite option). Regardless, I think that holding, forming and in various ways acting on political opinions is somewhere between unnecessary and significantly net harmful. I apologize in advance for not using concrete examples for anything in this post, but those would be political opinions.
 
-## Importance, Tractability, Neglectedness
+## Importance, tractability, neglectedness
 
 Political interaction is often framed as altruistic[^1] or even morally necessary - most notably, voting is a "civic duty"[^2], and it's common for political movements and their participants to believe that they are helping to bring about a better world through their actions, or that they're preventing some other group from doing harm (and thus in some sense doing good) with their ill-posed opinions, misaligned values or sheer evilness. Thus, let's evaluate it as an altruistic act using the [ITN](https://forum.effectivealtruism.org/topics/itn-framework) framework favoured by Effective Altruism. In brief, Importance is the value of fully solving whatever problem you're targeting, Tractability is the marginal value of your input to it (how much an additional unit of work can affect the problem), and Neglectedness is how little the problem is already being worked on.
 
@@ -19,9 +20,9 @@ Politics clearly fails at neglectedness. The majority of people are interested a
 
 It does not do well on tractability. For mostly the same reasons as neglectedness, your marginal contribution is not big. [Voting](https://putanumonit.com/2015/12/30/010-voting/) is, even under fairly optimistic assumptions, very unlikely to change the outcome of an election. Discussing politics with people you know is notorious for never changing anyone's beliefs, and arguments on social media are even less effective - very little discussion surfaces novel ideas and it mostly serves as an ineffective attempt to apply social pressure. The situation with protests and similar activity is perhaps better because there are fewer people doing that, but I do not think their effectiveness is going to be affected much by the addition or removal of a person on the margin, and I am not convinced that they do much in general. Politics is also especially intractable because on many issues, people are actively working against you.
 
-Importance is somewhat more ambiguous. I have been playing fast and loose with the exact definition of "politics" here - while it's clearly true that the sum of everything people want solved via politics is very important, the plausible consequences of something like electing a party you like or having a policy you want implemented are significantly smaller, both from the perspectives of [conflict theory](https://slatestarcodex.com/2018/01/24/conflict-vs-mistake/) (the frame of political disagreements as battles between groups over values or resource allocation) and mistake theory (political disagreements as good-faith discussions of what the best thing to do is given a shared understanding of goals). I found out while researching for this that policy changes are [actually surprisingly robust](https://forum.effectivealtruism.org/posts/jCwuozHHjeoLPLemB/how-long-do-policy-changes-matter-new-paper), but there are still problems - mistake-theroretically, the world is very complex and a policy may not actually do what you want, and, conflict-theoretically, an uncooperative government will not implement a policy in the way you want.
+Importance is somewhat more ambiguous. I have been playing fast and loose with the exact definition of "politics" here - while it's clearly true that the sum of everything people want solved via politics is very important, the plausible consequences of something like electing a party you like or having a policy you want implemented are significantly smaller, both from the perspectives of [conflict theory](https://slatestarcodex.com/2018/01/24/conflict-vs-mistake/) (the frame of political disagreements as battles between groups over values or resource allocation) and mistake theory (political disagreements as good-faith discussions of what the best thing to do is given a shared understanding of goals). I found out while researching for this that policy changes are [surprisingly robust](https://forum.effectivealtruism.org/posts/jCwuozHHjeoLPLemB/how-long-do-policy-changes-matter-new-paper), but there are still problems - mistake-theroretically, the world is very complex and a policy may not actually do what you want, and, conflict-theoretically, an uncooperative government will not implement a policy in the way you want.
 
-## The Magic Fix-Everything Button
+## The magic fix-everything button
 
 A large amount of modern politics-as-practiced seems to take a specific kind of conflict-theoretic view which I think makes it less important (in that the policies resulting from it will be worse) as well as less tractable (it's easier to persuade people if they don't tie opposing views into their identity, and easier to take actions if you are not battling some other group). Specifically, the belief that the main obstacle to improving the world is simply that evil people are in power, and that if you can demand it insistently enough you can replace them with favorable people who will then fix everything in a simple and obvious way which has heretofore gone unused. This is exemplified by [movements with unclear goals and underspecified demands to fix things](https://www.astralcodexten.com/p/book-review-the-revolt-of-the-public).
 
@@ -29,7 +30,7 @@ While there are absolutely some cases where a bad policy exists for conflict-the
 
 This can also lead to passivity and learned helplessness: not considering solutions to problems other than wrangling large-scale governmental mechanisms. This is also harmful, since the government is [not omnicompetent](https://www.theonion.com/smart-qualified-people-behind-the-scenes-keeping-ameri-1819571706) and anything complicated it does is mired in horrifying bureaucratic quagmires of impenetrable dysfunction, as are most large-scale organizations.
 
-## Selfish Reasons To Not Participate
+## Selfish reasons to not participate
 
 Rather than merely not being a public good, I think involvement in politics is even individually harmful. The most obvious reason is opportunity cost - all the time spent reading political news, voting, forming opinions, or having conversations about it could be spent more effectively - but there is the further reason that because people often tie politics to their identities, political discussions are frequently damaging to relationships or prevent people who would otherwise get on fine from doing so.
 
@@ -43,7 +44,7 @@ The most common objection I've heard is along the lines of "but if everyone did
 
 Another is the claim that I am a privileged person who is only able to ignore politics because I'm not heavily threatened or discriminated against by existing institutions. This is entirely missing the point: being more affected by something does not make you more able to affect it.
 
-The best I've had[^3] is that even if standard political engagement doesn't do anything, there are some activities considered "politics" which do work and which are reasonably accessible to individuals, such as local organization, engaging directly with figures in government or writing detailed policy proposals. This is plausibly true, but it's almost entirely orthogonal to most interaction, and having strong opinions on politics tends to bias your judgment of how effective and reasonable your actions actually are.
+The best I've had[^3] is that even if standard political engagement doesn't do anything, there are some activities considered "politics" which do work and which are reasonably accessible to individuals, such as local organization, engaging directly with figures in government or writing detailed policy proposals. This is plausibly true, but it's almost entirely orthogonal to most interaction, and having strong opinions on politics tends to bias your judgment of how effective and reasonable your actions truly are.
 
 If you have any arguments against my argument I haven't addressed here, please tell me so I can think about them.
 

blog/price-discrimination-by-cognitive-load.md

@@ -3,6 +3,7 @@ title: Price discrimination by cognitive load
 description: A slightly odd pattern I've observed.
 created: 16/10/2024
 slug: pricecog
+tags: ["economics"]
 ---
 Price discrimination is a practice where sellers of a product try to sell materially the same product to different customers at different prices closer to their willingness to pay. Economists probably have opinions on whether this is good or bad, but I'm going to focus on a specific mechanism for it here. Price discrimination requires some way to show different customers different prices: this might be through timing, very slightly different variants of the product, location or directly selling to customers without a public price.
 

blog/problem-solving.md

@@ -4,6 +4,7 @@ description: Is solving Sudoku and similar puzzles by hand really useful in buil
 slug: csproblem
 created: 20/05/2020
 uodated: 28/01/2023
+tags: ["education", "opinion"]
 ---
 
 *Co-written with Aidan, developer of [Emu War](/emu-war). He did most of it.*

blog/programming-education.md

@@ -3,6 +3,7 @@ title: Programming education, tacit knowledge and LLMs
 created: 02/07/2023
 description: Why programming education isn't very good, and my thoughts on AI code generation.
 slug: progedu
+tags: ["education", "opinion", "ai"]
 ---
 ::: epigraph attribution="Terry Pratchett"
 Education had been easy.
@@ -12,13 +13,13 @@ Learning things had been harder.
 
 It seems to be fairly well-known (or at least widely believed amongst the people I regularly talk to about this) that most people are not very good at writing code, even those who really "should" be because of having (theoretically) been taught to (see e.g. <https://web.archive.org/web/20150624150215/http://blog.codinghorror.com/why-cant-programmers-program/>). Why is this? In this article, I will describe my wild guesses.
 
-General criticisms of formal education have [already been done](https://en.wikipedia.org/wiki/The_Case_Against_Education), probably better than I can manage to do. I was originally going to write about how the incentives of the system are not particularly concerned with testing people in accurate ways, but rather easy and standardizable ways, and the easiest and most standardizable ways are to ask about irrelevant surface details rather than testing skill. But this isn't actually true: automated testing of code to solve problems is scaleable enough that things like [Project Euler](https://projecteuler.net/) and [Leetcode](https://leetcode.com/) can test vast amounts of people without human intervention, and it should generally be *less* effort to do this than to manually process written exams. It does seem to be the case that programming education tends to preferentially test bad proxies for actual skill, but the causality probably doesn't flow from testing methods.
+General criticisms of formal education have [already been done](https://en.wikipedia.org/wiki/The_Case_Against_Education), probably better than I can manage to do. I was originally going to write about how the incentives of the system are not particularly concerned with testing people in accurate ways, but rather easy and standardizable ways, and the easiest and most standardizable ways are to ask about irrelevant surface details rather than testing skill. But this isn't true: automated testing of code to solve problems is scaleable enough that things like [Project Euler](https://projecteuler.net/) and [Leetcode](https://leetcode.com/) can test vast amounts of people without human intervention, and it should generally be *less* effort to do this than to manually process written exams. It does seem to be the case that programming education tends to preferentially test bad proxies for actual skill, but the causality probably doesn't flow from testing methods.
 
 I think it's more plausible that teaching focuses on this surface knowledge because it's much easier and more legible, and looks and feels very much like "programming education" to someone who does not have actual domain knowledge (because other subjects are usually done in the same way), or who [isn't thinking very much about it](https://srconstantin.wordpress.com/2019/02/25/humans-who-are-not-concentrating-are-not-general-intelligences/), and then similar problems and a notion that testing should be "fair" and "cover what students have learned" lead to insufficiently outcome-oriented exams, which then sets up incentives biasing students in similar directions. The underlying issue is a matter of "tacit knowledge": being good at programming requires sets of interlocking and hard-to-describe mental heuristics rather than a long list of memorized rules, and since applying them feels natural and easy - and most people who are now competent don't accurately remember lacking them - it is not immediately obvious that this is the case, and someone asked how they can do something is likely to focus on the things which are, to them, easier to explain and notice.
 
 So why is programming education particularly bad? Shouldn't *every* field be harmed by tacit knowledge transmission problems? My speculative answer is that they generally are, but it's much less noticeable and plausibly also a smaller problem. The heuristics used in programming are strange and unnatural - I'll describe a few of the important ones later - but the overarching theme is that programming is highly reductionist: you have to model a system very different to your own mind, and every abstraction breaks down in some corner case you will eventually have to know about. The human mind very much likes pretending that other systems are more or less identical to it - [animism](https://en.wikipedia.org/wiki/Animism) is no longer a particularly popular explicitly-held belief system, but it's still common to ascribe intention to machinery, "fate" and "karma", animals without very sophisticated cognition, and a wide range of other phenomena. Computers are not at all human, in that they do exactly what someone has set them up to do, which is often [not what they thought they were doing](https://gwern.net/unseeing), while many beginners expect them to "understand what they meant" and act accordingly. Every simple-looking capability is burdened with detail[^1]: the computer "knows what time it is" (thanks to some [nontrivial engineering](https://en.wikipedia.org/wiki/Network_Time_Protocol) with some possible failure points); the out-of-order CPU "runs just like an abstract in-order machine, but very fast" (until security researchers [find a difference](https://en.wikipedia.org/wiki/Meltdown_(security_vulnerability))); DNS "resolves domain names to IPs" (but is frequently intercepted by networks, and can also serve as a covert backchannel); video codecs "make videos smaller" (but are also [complex domain-specific programming languages](https://wrv.github.io/h26forge.pdf)); text rendering "is just copying bitmaps into the right places" ([unless you care about Unicode or antialiasing or kerning](https://faultlore.com/blah/text-hates-you/)).
 
-The other fields which I think suffer most are maths and physics. Maths education mostly [fails to convey what mathematicians actually care about](/assets/misc/LockhartsLament.pdf) and, despite some attempts to vaguely gesture at it, does not teach "problem-solving" skills as much as sometimes set nontrivial multistep problems and see if some people manage to solve them. Years of physics instruction [fail to stop many students falling back to Aristotelian mechanics](https://www.researchgate.net/profile/Richard-Gunstone/publication/238983736_Student_understanding_in_mechanics_A_large_population_survey/links/02e7e52f8a2f984024000000/Student-understanding-in-mechanics-A-large-population-survey.pdf) on qualitative questions. This is apparently mostly ignored, perhaps because knowledge without deep understanding is sufficient for many uses and enough people generalize to the interesting parts to supply research, but programming makes the problems more obvious, since essentially any useful work will rapidly run into things like debugging.
+The other fields which I think suffer most are maths and physics. Maths education mostly [fails to convey what mathematicians really care about](/assets/misc/LockhartsLament.pdf) and, despite some attempts to vaguely gesture at it, does not teach "problem-solving" skills as much as sometimes set nontrivial multistep problems and see if some people manage to solve them. Years of physics instruction [fail to stop many students falling back to Aristotelian mechanics](https://www.researchgate.net/profile/Richard-Gunstone/publication/238983736_Student_understanding_in_mechanics_A_large_population_survey/links/02e7e52f8a2f984024000000/Student-understanding-in-mechanics-A-large-population-survey.pdf) on qualitative questions. This is apparently mostly ignored, perhaps because knowledge without deep understanding is sufficient for many uses and enough people generalize to the interesting parts to supply research, but programming makes the problems more obvious, since essentially any useful work will rapidly run into things like debugging.
 
 So what can be done? I don't know. Formal education is likely a lost cause: incentives aren't aligned enough that a better way to teach would be adopted any time soon, even if I had one, and enough has been invested in existing methods that any change would be extremely challenging. I do, at least, have a rough idea of what good programmers have which isn't being taught well, but I don't know how you *would* teach these things effectively:
 
@@ -27,14 +28,14 @@ So what can be done? I don't know. Formal education is likely a lost cause: ince
 * Effective tool use - things like using Git and basic knowledge of Linux commands are frequently taught, but this is not really what I mean. Good programmers can select a novel tool for a particular task and quickly learn its most important capabilities, and have a smaller set of tools they know very well and can operate fast. A particularly good quick-to-operate tool can become an extension of your mental processes, at least when at a computer. I think fast typing is somewhat underappreciated, though I may be biased.
 * Rough full-stack knowledge - while knowing everything about modern computers is probably literally impossible in a human lifetime, broad knowledge is necessary to guess at where bugs might arise, as many of them come from interactions between your code and other systems.
 * Security mindset: as well as being directly useful for ensuring security, always thinking about where your assumptions might be flawed or how something might go wrong is vital for reliability.
-* Good code structuring, e.g. knowing when to disaggregate or aggregate modules. I think that lots of people, particularly when using OOP, are too quick to try and "break apart" interdependent code in a way which makes development much slower without actually providing much flexibility, but thousand-line files with global variables everywhere are hard to work on.
+* Good code structuring, e.g. knowing when to disaggregate or aggregate modules. I think that lots of people, particularly when using OOP, are too quick to try and "break apart" interdependent code in a way which makes development much slower without providing much flexibility, but thousand-line files with global variables everywhere are hard to work on.
 
 If you have been paying any attention to anything within the past [two years](https://openai.com/blog/openai-codex/) or so, you're probably also aware that AI (specifically large language models) will obsolete, augment, change, or do nothing whatsoever to software engineering jobs. My previous list provides some perspective for this: ChatGPT (GPT-3.5 versions; I haven't used the GPT-4 one) can model computers well enough that it can [pretend to be a Linux shell](https://www.engraved.blog/building-a-virtual-machine-inside/) quite accurately, tracking decent amounts of state while it does so; big language models have vague knowledge of basically everything on the internet, even if they don't always connect it well; ChatGPT can [also](https://twitter.com/gf_256/status/1598104835848798208) find some vulnerabilities in code; [tool use](https://til.simonwillison.net/llms/python-react-pattern) [is continually](https://openai.com/blog/function-calling-and-other-api-updates) [being](https://gorilla.cs.berkeley.edu/) [improved](https://twitter.com/emollick/status/1657050639644360706) (probably their quick-script-writing capability already exceeds most humans'). Not every capability is there yet, of course, and I think LLMs are significantly hampered by issues humans don't have, like context window limitations, lack of online learning, and bad planning ability, but these are probably not that fundamental.
 
-Essentially, your job is probably not safe, as long as development continues (and big organizations actually notice).
+Essentially, your job is probably not safe, as long as development continues (and big organizations notice).
 
 You may contend that LLMs lack "general intelligence", and thus can't solve novel problems, devise clever new algorithms, etc. I don't think this is exactly right (it's probably a matter of degree rather than binary), but my more interesting objection is that most code doesn't involve anything like that. Most algorithmic problems have already been solved somewhere if you can frame them right[^2] (which is, in fairness, also a problem of intelligence, but less so than deriving the solution from scratch), and LLMs probably remember more algorithms than you. More than that, however, most code doesn't even involve sophisticated algorithms: it just has to move some data around or convert between formats or call out to libraries or APIs in the right order or process some forms. I don't really like writing that and try to minimize it, but this only goes so far. You may also have a stronger objection along the line of "LLMs are just stochastic parrots repeating patterns in their training data": this is wrong, and you may direct complaints regarding this to the comments or [microblog](https://b.osmarks.net/), where I will probably ignore them.
 
 [^1]: The particular examples here are not ones you're likely to run into for a while, but anyone who writes code for long enough is going to encounter *something* weird.
 
-[^2]: Notably, people who have spent more time on Leetcode than me claim that it is actually just about memorizing a few algorithms which it then uses for a wide range of thinly disguised problems.
+[^2]: Notably, people who have spent more time on Leetcode than me claim that it is generally about memorizing a few algorithms which it then uses for a wide range of thinly disguised problems.

blog/rote-memorization-good.md

@@ -3,13 +3,14 @@ title: Against being against rote memorization
 description: A common criticism of school is that it focuses overmuch on rote memorization. While I don't endorse school, I think this argument is wrong.
 slug: rote
 created: 28/01/2023
+tags: ["education", "opinion"]
 ---
 It is popular to be against rote-memorizing things (i.e. spending time to deliberately commit things exactly to memory) and in favour of something like learning "problem-solving"; I think this is a false dichotomy and memorization can help with more advanced skills.
 
 ## Remembering things is faster than using reference materials
 
 A common argument made against reliance on external tools for cognition like calculators is that you "won't always have them".
-Obviously in today's world of ubiquitous portable computers this is mostly wrong in noncontrived situations, but a better reason is that they're not tightly integrated enough; access is *very slow*. 
+Obviously in today's world of ubiquitous portable computers this is mostly wrong in noncontrived situations, but a better reason is that they're not tightly integrated enough; access is *very slow*.
 Even with the best search tools it's generally faster to recall things (assuming they're not extremely long and you remember them well) than to retrieve and consult relevant notes.
 This can be a significant bottleneck: imagine how much slower mental arithmetic would be if you had to look up the results of single-digit operations each time.
 Even if the time cost isn't that large, it can still be problematic via removing you from "flow".
@@ -24,4 +25,4 @@ Being able to effectively "problem-solve" requires making this kind of connectio
 
 A naïve flashcard system which shows you all the things you need to remember every day would be a terrible timesink and probably not worth using.
 Fortunately, this is not at all necessary: research has elicited a decent model of how we remember and forget things, and it turns out that the time you retain a memory for increases each time you see it again.
-This insight has been incorporated into "spaced repetition systems" like [Anki](https://apps.ankiweb.net/), which only show you things frequently enough to keep them memorized, meaning that you can learn a fact with only a few minutes of lifetime time investment.
+This insight has been incorporated into "spaced repetition systems" like [Anki](https://apps.ankiweb.net/), which only show you things frequently enough to keep them memorized, meaning that you can learn a fact with only a few minutes of lifetime time investment.

blog/rssgood.md

@@ -2,6 +2,7 @@
 title: "RSS: good and useful"
 description: RSS/Atom are protocols for Internet-based newsletter/feed services. They're surprisingly well-supported and you should consider using them.
 created: 14/05/2022
+tags: ["opinion", "web"]
 ---
 RSS stands for Really Simple Syndication, and it's an underappreciated protocol for generally "following" things on the internet.
 Most people do this via proprietary platforms with feed/notification functionality, the problems of which are obvious, or email.
@@ -18,7 +19,7 @@ Yes, despite RSS's relative lack of use nowadays, a surprisingly large amount of
 * WordPress, a very popular platform for blogs, has RSS support enabled by default (just go to `/feed/`).
 * YouTube has RSS feeds for channels' videos: `https://www.youtube.com/feeds/videos.xml?channel_id=[ID of channel to follow]`.
 * Some web fiction sites (e.g. Royal Road, Archive Of Our Own) have per-story RSS feeds.
-* osmarks.net has an RSS feed, linked on the main page somewhere: [https://osmarks.net/rss.xml](https://osmarks.net/rss.xml) - this does only cover blog posts and not experiments, as those aren't actually timestamped.
+* osmarks.net has an RSS feed, linked on the main page somewhere: [https://osmarks.net/rss.xml](https://osmarks.net/rss.xml) - this does only cover blog posts and not experiments, as those aren't timestamped.
 * Blogspot blogs have feeds at `/rss.xml`.
 * The BBC has RSS feeds described here: [https://www.bbc.com/news/10628494](https://www.bbc.com/news/10628494).
 * Otherwise, you can ctrl+F for "RSS" or "Atom" or "feed" or "subscribe" and might be successful, or try URLs like `/feed`, `/feed.xml`, `/feed.atom`, `/index.xml`, `/rss` or `/rss.xml`.
@@ -26,4 +27,4 @@ Yes, despite RSS's relative lack of use nowadays, a surprisingly large amount of
 As for RSS readers to use these with, there are many implementations available.
 I use [Miniflux](https://miniflux.app/), since it's self-hosted and accessible on multiple devices via the web, and has nice features like keyboard controls, scraping websites which omit some content from RSS feeds, and an integration API which I use to plug it into my convoluted mess of custom scripting.
 The [Awesome Self-Hosted list](https://github.com/awesome-selfhosted/awesome-selfhosted#feed-readers) has many other reader applications like this.
-If you prefer something which runs locally as a desktop application, [Wikipedia has a list](https://en.wikipedia.org/wiki/Comparison_of_feed_aggregators) (I haven't actually checked this space myself).
+If you prefer something which runs locally as a desktop application, [Wikipedia has a list](https://en.wikipedia.org/wiki/Comparison_of_feed_aggregators) (I haven't actually checked this space myself).

blog/scaling-meme-search.md

@@ -5,6 +5,7 @@ created: 24/01/2025
 series: meme_search
 series_index: 3
 slug: memescale
+tags: ["own tech", "ai", "search", "memes"]
 ---
 ::: emphasis
 Try the new search system [here](https://nooscope.osmarks.net/). I don't intend to replace the existing [Meme Search Engine](https://mse.osmarks.net/), as its more curated dataset is more useful to me for most applications.

blog/stack-rsapi.md

@@ -5,6 +5,7 @@ created: 27/03/2024
 slug: srsapi
 series: stack
 series_index: 2
+tags: ["own tech"]
 ---
 ::: epigraph attribution=@creatine_cycle link=https://twitter.com/creatine_cycle/status/1661455402033369088
 Transhumanism is attractive until you have seen how software is built.

blog/stack.md

@@ -5,6 +5,7 @@ created: 24/02/2022
 updated: 08/04/2025
 series: stack
 series_index: 1
+tags: ["own tech", "linux"]
 ---
 ::: epigraph attribution="Rupert Goodwins"
 If you can't stand the heat, get out of the server room.

blog/stop-making-chatbots.md

@@ -3,6 +3,7 @@ title: AI interface design
 description: Please stop making chatbots.
 slug: nochatbots
 created: 27/04/2024
+tags: ["ai", "opinion"]
 ---
 ::: epigraph attribution="Leo Gao" link=https://twitter.com/nabla_theta/status/1776427242748609022
 While computers may excel at soft skills like creativity and emotional understanding, they will never match human ability at dispassionate, mechanical reasoning.
@@ -30,4 +31,4 @@ Think about what workflows your users need and how you can serve them with a wel
 
 [^4]: Arguably, this means a really good tool loves you. Maybe this is where waifutech comes from.
 
-[^5]: There are a few cases - notably, having LLMs write scripts, and search engines and the like - where you actually *can* service a very wide range of possible inputs. Those are fine. Most situations aren't like that.
+[^5]: There are a few cases - notably, having LLMs write scripts, and search engines and the like - where you actually *can* service a very wide range of possible inputs. Those are fine. Most situations aren't like that.

blog/superintelligence-lower-bounds.md

@@ -3,6 +3,7 @@ title: Against some assumed limits on superintelligence
 description: The TAM for God is very large.
 created: 02/03/2025
 slug: asi
+tags: ["ai"]
 ---
 ::: epigraph attribution="Void Star" link=/otherstuff/#void-star
 It’s not a trick. You’ll die if you go on, but it’s not a trick. I know something of your nature. Do you really want to go back to the decay of your biology and days like an endless reshuffling of a fixed set of forms? What the world has, you’ve seen. This is the only other way.
@@ -43,7 +44,7 @@ But focus on concrete tasks I can think of myself is rather missing the point. D
 
 Due to limited working memory and the necessity of distributing subtasks in an organization, humans design and model systems based on abstraction - rounding off low-level detail to produce a homogeneous overview with fewer free parameters. [Seeing Like a State](https://en.wikipedia.org/wiki/Seeing_Like_a_State)[^1] describes how this has gone wrong historically - states, wanting the world to be easier to manage, bulldoze fine-tuned local knowledge and install simple rules and neat rectangles which produce worse outcomes. I think this case is somewhat overstated, because abstraction does often work better than the alternatives. People can't simultaneously attend to the high-level requirements of their problem and every low-level point, so myopic focus on the low-level detracts from the overall quality of the result[^2] - given the limitations of humans.
 
-Abstraction amortises intellect, taking good solutions to simpler and more general problems and applying them on any close-enough substrate. This has brought us many successes like industrial farming, digital computers and assembly lines. But an end-to-end design not as concerned with modularity and legibility will usually outperform one based on generalities, if you can afford the intellectual labour, through better addressing cross-cutting concerns, precise tailoring to small quirks and making simplifications across layers of the stack. Due to organizational issues, the cost of human intelligence, and working memory limitations, this frequently doesn't happen. [This book](https://www.construction-physics.com/p/book-review-building-an-affordable) describes some object-level examples in house construction and [this blog post](https://yosefk.com/blog/my-history-with-forth-stack-machines.html) suggests that Forth is this for computing.
+Abstraction amortises intellect, taking good solutions to simpler and more general problems and applying them on any close-enough substrate. This has brought us many successes like industrial farming, digital computers and assembly lines. But an end-to-end design not as concerned with modularity and legibility will usually outperform one based on generalities, if you can afford the intellectual labour, through better addressing cross-cutting concerns, precise tailoring to small quirks and making simplifications across layers of the stack. Due to organizational issues, the cost of human intelligence, and working memory limitations, this frequently doesn't happen. [This book](https://www.construction-physics.com/p/book-review-building-an-affordable) describes some object-level examples in house construction and [this blog post](https://yosefk.com/blog/my-history-with-forth-stack-machines.html) suggests that Forth is this for computing. See also [Anton](https://www.hc33.hotchips.org/assets/program/conference/day2/HC2021.DESRES.AdamButts.v03.pdf): by designing computers end-to-end for molecular dynamics, D E Shaw Research managed 100x speedups over standard supercomputers.
 
 We see the abstractions still even when they have gaps, and this is usually a security threat. A hacker doesn't care that you think your code "parses XML" or "checks authentication" - they care about [what you actually wrote down](https://gwern.net/unseeing), and what the computer will do with it[^3], which is quite possibly [not what you intended](https://blog.siguza.net/psychicpaper/). Your nice "secure" cryptographic code is [running on hardware](http://wiki.newae.com/Correlation_Power_Analysis) which reveals correlates of what it's doing. Your "air-gapped" computer is able to emit [sounds](https://arxiv.org/abs/2409.04930v1) and [radio signals](https://arxiv.org/abs/2207.07413) and [is connected to power cables](https://pushstack.wordpress.com/2017/07/24/data-exfiltration-from-air-gapped-systems-using-power-line-communication/). A "blank wall" [leaks information](https://www.cs.princeton.edu/~fheide/steadystatenlos) through diffuse reflections. Commodity "communication" hardware can [sense people](https://www.usenix.org/system/files/nsdi24-yi.pdf), because the signals travel through the same physical medium as everything else. Strange side channels are everywhere and systematically underestimated. These are the examples we *have* found, but new security vulnerabilities are detected continually and I am confident that essentially all complex software is hopelessly broken in at least one way.
 
@@ -55,7 +56,7 @@ In many areas we have a concrete example of what something highly optimized by a
 
 ## Data is no barrier
 
-Superhuman AI/optimization systems are usually trained on much more data than a human will ever see - state-of-the-art image classifiers and language models see billions of webpages in pretraining, AlphaGo Zero played[^7] 5 million games against itself, and a recent [self-driving car RL paper](https://arxiv.org/abs/2502.03349) used 1 trillion steps/10000 simulated driver-years to achieve state-of-the-art performance. This suggests that a superintelligence could not rapidly outperform humans without conducting experiments in the areas humans haven't looked at hard and aren't good at. I think this is not true, and that it wouldn't be a binding limit if it was.
+Superhuman AI/optimization systems are usually trained on much more data than a human will ever see - state-of-the-art image classifiers and language models see billions of webpages in pretraining, AlphaGo Zero played[^7] 5 million games against itself, and a recent [self-driving car RL paper](https://arxiv.org/abs/2502.03349) used 1 trillion steps/10000 simulated driver-years to achieve state-of-the-art performance. This suggests that a superintelligence could not rapidly outperform humans without conducting experiments in the areas humans haven't looked at hard and aren't good at. I think this is not true, and that it wouldn't be a binding limit if it was[^18].
 
 The biggest discovery in deep learning in the past decade[^8], which many still don't understand, is scaling laws: the performance of a particular model architecture scales predictably with compute. Often the compute-optimal forms are quoted without nuance - many take the [Chinchilla paper](https://arxiv.org/abs/2203.15556) to mean "you must train LLMs on ~20 tokens per parameter" - but it's also possible to use more data and fewer parameters, or less data and more parameters, for roughly the same downstream performance, with one data/parameter count setting minimizing compute iso-performance[^12]. RL [also has](https://arxiv.org/abs/2502.04327) similar tradeoffs, though parameter count scaling is trickier[^9] so updates-per-data is varied instead. This makes sample efficiency an economic question rather than a theoretical one.
 
@@ -130,3 +131,5 @@ Enough of the world is bottlenecked on (availability of) human intelligence, rat
 [^16]: Most benchmarks for LLMs and image models contain many wrong answers, so nothing can *achieve* a 100% score, except by perfectly modelling all the highly contingent human mistakes.
 
 [^17]: This may centrally be an I/O limitation.
+
+[^18]: This section uses mostly evidence from deep learning. It is possible that ASI won't be built this way (though I personally expect it to be), but whatever is used should be "at least as good" in these ways.

links_cache.json

@@ -3874,5 +3874,189 @@
         "date": null,
         "website": null,
         "auto": true
+    },
+    "https://squiddev.github.io/ae-sat/": {
+        "excerpt": "Disclaimer: I am by no means an expert in this sort of thing so please do correct me if I get things entirely\nwrong! I should also warn you that, whilst I’ll try to keep this as accessible as possible, some prior\nprogramming/comp-sci knowledge is recommended.",
+        "title": "Autocrafting is NP-hard | squiddev.github.io",
+        "author": null,
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Boolean_satisfiability_problem": {
+        "excerpt": "\"3SAT\" redirects here. For the Central European television network, see 3sat.",
+        "title": "Boolean satisfiability problem",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2001-12-03T09:36:45Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Benford%27s_law": {
+        "excerpt": "Benford's law, also known as the Newcomb–Benford law, the law of anomalous numbers, or the first-digit law, is an observation that in many real-life sets of numerical data, the leading digit is likely to be small.[1] In sets that obey the law, the number 1 appears as the leading significant digit about 30% of the time, while 9 appears as the leading significant digit less than 5% of the time. Uniformly distributed digits would each occur about 11.1% of the time.[2] Benford's law also makes predictions about the distribution of second digits, third digits, digit combinations, and so on.",
+        "title": "Benford's law",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2002-02-02T10:34:10Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://gwern.net/oen": {
+        "excerpt": "Proposal to create a ‘search engine’ like OEIS but for individual\nnumbers, allowing fuzzy lookups, by training a neural net embedding on\nthe scientific & mathematic literature’s corpus of co-occurring\nnumbers, and by known special transformations.",
+        "title": "Number Search Engine via NN Embeddings",
+        "author": "Gwern",
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://pile.eleuther.ai/": {
+        "excerpt": "The Pile is a 825 GiB diverse, open source language modelling data set that consists of 22 smaller, high-quality datasets combined together.",
+        "title": "The Pile",
+        "author": null,
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Pareto_distribution": {
+        "excerpt": "Probability density function",
+        "title": "Pareto distribution",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2002-05-23T05:25:13Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://github.com/osmarks/misc/blob/master/empirical-number-distribution/src/main.rs": {
+        "excerpt": "In the interest of transparency and/or their great value to society, I'm releasing my smaller projects/scripts upon an unsuspecting public. - osmarks/misc",
+        "title": "misc/empirical-number-distribution/src/main.rs at master · osmarks/misc",
+        "author": "osmarks",
+        "date": null,
+        "website": "GitHub",
+        "auto": true
+    },
+    "https://docs.minecraftforge.net/en/1.12.x/utilities/oredictionary/": {
+        "excerpt": "The OreDictionary exists primarily for inter-mod compatibility.",
+        "title": "OreDictionary - Forge Documentation",
+        "author": null,
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://minecraft.wiki/w/Item_tag_(Java_Edition)": {
+        "excerpt": "An item tag is a group of items. They are used when a recipe allows multiple different items as inputs and control many other gameplay features. See below for the use of each item tag. They can also be used when testing for item arguments in commands with #<resource location>, which succeeds if the item matches any of the items specified in the tag, and can be searched in the creative inventory by searching #<resource location>.",
+        "title": "Item tag (Java Edition) – Minecraft Wiki",
+        "author": null,
+        "date": null,
+        "website": "Minecraft Wiki",
+        "auto": true
+    },
+    "https://github.com/AppliedEnergistics/Applied-Energistics-2/blob/70838d74f81917ece64335db2aca3cb3a604b780/src/main/java/appeng/crafting/CraftingTreeNode.java": {
+        "excerpt": "A Minecraft Mod about Matter, Energy and using them to conquer the world.. - AppliedEnergistics/Applied-Energistics-2",
+        "title": "Applied-Energistics-2/src/main/java/appeng/crafting/CraftingTreeNode.java at 70838d74f81917ece64335db2aca3cb3a604b780 · AppliedEnergistics/Applied-Energistics-2",
+        "author": "AppliedEnergistics",
+        "date": null,
+        "website": "GitHub",
+        "auto": true
+    },
+    "https://github.com/refinedmods/refinedstorage2/blob/accdcf28c52752c1512c16b97efad7b59ab3b340/refinedstorage-autocrafting-api/src/main/java/com/refinedmods/refinedstorage/api/autocrafting/calculation/CraftingTree.java": {
+        "excerpt": "Refined Storage is a mass storage mod for Minecraft that offers the player a network-based storage system, allowing them to store items and fluids on a massively expandable device network. - refine...",
+        "title": "refinedstorage2/refinedstorage-autocrafting-api/src/main/java/com/refinedmods/refinedstorage/api/autocrafting/calculation/CraftingTree.java at accdcf28c52752c1512c16b97efad7b59ab3b340 · refinedmods/refinedstorage2",
+        "author": "refinedmods",
+        "date": null,
+        "website": "GitHub",
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/P_versus_NP_problem": {
+        "excerpt": "Unsolved problem in computer science",
+        "title": "P versus NP problem",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2001-08-26T23:04:30Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Satisfiability_modulo_theories": {
+        "excerpt": "From Wikipedia, the free encyclopedia",
+        "title": "Satisfiability modulo theories",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2006-05-14T07:25:59Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://borretti.me/fiction/eog581/the-lunar-surface": {
+        "excerpt": "life in amber — nothing left — Rijndael",
+        "title": "The Lunar Surface",
+        "author": "Fernando Borretti",
+        "date": "2022-11-15T00:00:00+00:00",
+        "website": "Fernando Borretti",
+        "auto": true
+    },
+    "https://alexanderwales.com/instruments-of-destruction/": {
+        "excerpt": "Author’s Note: This is largely a story about project management. Adherence to canon not guaranteed.",
+        "title": "Instruments of Destruction – Alexander Wales",
+        "author": null,
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Margin_Call": {
+        "excerpt": "From Wikipedia, the free encyclopedia",
+        "title": "Margin Call",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2010-06-27T05:06:38Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Upload_(TV_series)": {
+        "excerpt": "From Wikipedia, the free encyclopedia",
+        "title": "Upload (TV series)",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2018-07-28T22:34:51Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://www.reddit.com/r/feedthebeast/comments/7t8v0o/autocrafting_is_npcomplete/dtbgkz9/": {
+        "excerpt": "Reddit and its partners use cookies and similar technologies to provide you with a better experience. By accepting all cookies, you agree to our use of cookies to deliver and maintain our services and site, improve the quality of Reddit, personalize Reddit content and advertising, and measure the effectiveness of advertising. By rejecting non-essential cookies, Reddit may still use certain cookies to ensure the proper functionality of our platform.\n            For more information, please see our\n        Cookie Notice\n        and our\n        Privacy Policy.",
+        "title": "The heart of the internet",
+        "author": null,
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://guide.appliedenergistics.org/1.20.4/example-setups/recursive-crafting-setup": {
+        "excerpt": "As stated in autocrafting, the autocrafting planning algorithm cannot handle recipes where\nthe primary output is one of the inputs. For example, it cannot handle cloning Smithing Templates.",
+        "title": "A Recursive Crafting Setup - AE2 Players Guide for 1.20.4",
+        "author": null,
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Petri_net": {
+        "excerpt": "A Petri net, also known as a place/transition net (PT net), is one of several mathematical modeling languages for the description of distributed systems.  It is a class of discrete event dynamic system. A Petri net is a directed bipartite graph that has two types of elements: places and transitions. Place elements are depicted as white circles and transition elements are depicted as rectangles. \nA place can contain any number of tokens, depicted as black circles. A transition is enabled if all places connected to it as inputs contain at least one token. Some sources[1] state that Petri nets were invented in August 1939 by Carl Adam Petri — at the age of 13 — for the purpose of describing chemical processes.",
+        "title": "Petri net",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2003-05-11T14:43:22Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://en.wikipedia.org/wiki/Vector_addition_system": {
+        "excerpt": "From Wikipedia, the free encyclopedia",
+        "title": "Vector addition system",
+        "author": "Contributors to Wikimedia projects",
+        "date": "2015-01-18T22:16:29Z",
+        "website": "Wikimedia Foundation, Inc.",
+        "auto": true
+    },
+    "https://www.sciencedirect.com/science/article/pii/S0019995883800229": {
+        "excerpt": "Commutative grammars are introduced, and various classes of commutative grammars are defined. The complexity of uniform word problems for commutative …",
+        "title": "Commutative grammars: The complexity of uniform word problems",
+        "author": "Author links open overlay panelDung T. Huynh *",
+        "date": null,
+        "website": null,
+        "auto": true
+    },
+    "https://github.com/osmarks/misc/blob/master/autocrafter.py": {
+        "excerpt": "In the interest of transparency and/or their great value to society, I'm releasing my smaller projects/scripts upon an unsuspecting public. - osmarks/misc",
+        "title": "misc/autocrafter.py at master · osmarks/misc",
+        "author": "osmarks",
+        "date": null,
+        "website": "GitHub",
+        "auto": true
     }
 }

package.json

@@ -22,6 +22,7 @@
     "fs-extra": "^8.1.0",
     "gray-matter": "^4.0.2",
     "handlebars": "^4.7.6",
+    "highlight.js": "^11.11.1",
     "html-minifier": "^4.0.0",
     "html-to-text": "^9.0.5",
     "idb": "^7.1.1",

src/global.json

@@ -103,6 +103,6 @@
         "economics": "#15b01a",
         "opinion": "#fdaa48",
         "own tech": "#04d8b2",
-        "maths": "#f8481c"
+        "maths": "#9f2305"
     }
 }

templates/index.pug

@@ -7,7 +7,7 @@ block content
             Read my opinions via the internet.
         div.blog
             each post, i in posts
-                .box.imbox
+                .box.imbox(style=post.accentColor && `--stripe: ${post.accentColor}`)
                     if images.hasOwnProperty(post.slug)
                         +image(images[post.slug])
                     div

templates/layout.pug

@@ -31,6 +31,8 @@ html(lang="en")
         meta(content=`https://${domain}/assets/images/logo256.png`, property="og:image")
         if katex
             link(rel="stylesheet", href="/assets/katex.min.css")
+        if highlightCode
+            link(rel="stylesheet", href="/assets/highlight.min.css")
         link(rel="alternate", type="application/rss+xml", title="RSS", href="/rss.xml")
         style!= css
         if comments !== "off"