Terry Pratchett, Jingo (1997) -- War keeps threatening to break out between Ankh-Morpork and Klatch, to the bedraggled annoyance of Sir Samuel Vimes, Commander of the City Watch.
I've been trying to read/reread all the Discworld books in order, but at some point I got mixed up and had to jog backwards for
Hogfather and
Jingo.
Hogfather was great, but
Jingo is the pits: plot incomprehensible, hacky jokes, and the kind of "ironic" racism that presumably read as progressive in the mid-90s and has, in the years since, aged like milk. It sucked! I guess its one redeeming value is that it makes me feel somewhat more tolerant in retrospect toward
The Fifth Elephant, which I also
hated. I didn't love
The Fifth Elephant's handling of Angua, but at least she and Carrot get to be rounded and vulnerable characters in that one, unlike whatever the fuck is going on with them in
Jingo. (Also, I suspect the climactic assassination at the end of
The Fifth Elephant is meant to rhyme with Vimes's near-assassination attempt in
Jingo, but Pratchett does not successfully pull it off in either novel.)
In conclusion, 1997-1999 saw the publication of
Jingo,
The Last Continent,
Carpe Jugulum, and
The Fifth Elephant. It was a rough couple of years for the Discworld series.
T. Kingfisher, What Moves The Dead (2022) -- A houseguest tries to figure out what's going on at the very strange House of Usher.
This novella-length retelling of Poe's "The Fall of the House of Usher" feels unnecessary. Poe's weird siblings, Madeline and Roderick Usher, get reconfigured, with a much larger role for Madeline, and the plot is remixed with a Lovecraftian horror lurking in the background, but
What Moves The Dead does not use its source material in an interesting or illuminating way. I'm not a huge Poe fan (the first half of the 19th century was a particularly dire time in American letters), but this novella is a markedly unambitious take on Poe.
Jacqueline Winspear, Maisie Dobbs (2003) -- In the aftermath of World War I, a former nurse sets up shop as a consulting detective in London.
This was an odd one. It has such a determined air of moral improvement and such an emphasis on constant virtue that I had to double-check that it was not published by a Christian press. It has the vibe of one of those very "clean" romance novels passed around by a grandmother's church group -- not because
Maisie Dobbs is religious, and not because it features a typical romance-novel plot, but because its moral world is black-and-white and its characters are stiffly didactic. It's...a weird mode for a detective novel, a genre which is usually not chockablock with earnest homilies. The novel travels down an extremely mild and sedate track for most of the plot, only to spring a truly bonkers finale that seems straight out of a different and
way more lurid novel. What a choice! What a weird book!
![[personal profile]](https://www.dreamwidth.org/img/silk/identity/user.png)
yuletidemods) wrote in ![[community profile]](https://www.dreamwidth.org/img/silk/identity/community.png)
yuletide_admin2025-12-14 11:09 am
I think there are many.
Some examples:
* The fastest code is the code you don't run.
Smaller = faster, and we all want faster. Moore's law is over, Dennard scaling isn't affordable any more, smaller feature sizes are getting absurdly difficult and therefore expensive to fab. So if we want our computers to keep getting faster as we've got used to over the last 40-50 years then the only way to keep delivering that will be to start ruthlessly optimising, shrinking, finding more efficient ways to implement what we've got used to.
Smaller systems are better for performance.
* The smaller the code, the less there is to go wrong.
Smaller doesn't just mean faster, it should mean simpler and cleaner too. Less to go wrong. Easier to debug. Wrappers and VMs and bytecodes and runtimes are bad: they make life easier but they are less efficient and make issues harder to troubleshoot. Part of the Unix philosophy is to embed the KISS principle.
So that's performance and troubleshooting. We aren't done.
* The less you run, the smaller the attack surface.
Smaller code and less code means fewer APIs, fewer interfaces, less points of failure. Look at djb's decades-long policy of offering rewards to people who find holes in qmail or djbdns. Look at OpenBSD. We all need better more secure code. Smaller simpler systems built from fewer layers means more security, less attack surface, less to audit.
Higher performance, and easier troubleshooting, and better security. There's 3 reasons.
Practical examples...
The Atom editor spawned an entire class of app: Electron apps, Javascript on Node, bundled with Chromium. Slack, Discord, VSCode: there are multiple apps used by tens to hundreds of millions of people now. Look at how vast they are. Balena Etcher is a, what, nearly 100 MB download to write an image to USB? Native apps like Rufus do it in a few megabytes. Smaller ones like USBimager do it in hundreds of kilobytes. A dd command in under 100 bytes.
Now some of the people behind Atom wrote Zed.
It's 10% of the size and 10x the speed, in part because it's a native Rust app.
The COSMIC desktop looks like GNOME, works like GNOME Shell, but it's smaller and faster and more customisable because it's native Rust code.
GNOME Shell is Javascript running on an embedded copy of Mozilla's Javascript runtime.
Just like dotcoms wanted to dis-intermediate business, remove middlemen and distributors for faster sales, we could use disintermediation in our software. Fewer runtimes, better smarter compiled languages so we can trap more errors and have faster and safer compiled native code.
Smaller, simpler, cleaner, fewer layers, less abstractions: these are all goods things which are desirable.
Dennis Ritchie and Ken Thompson knew this. That's why Research Unix evolved into Plan 9, which puts way more stuff through the filesystem to remove whole types of API. Everything's in a container all the time, the filesystem abstracts the network and the GUI and more. Under 10% of the syscalls of Linux, the kernel is 5MB of source, and yet it has much of Kubernetes in there.
Then they went further, replaced C too, made a simpler safer language, embedded its runtime right into the kernel, and made binaries CPU-independent, and turned the entire network-aware OS into a runtime to compete with the JVM, so it could run as a browser plugin as well as a bare-metal OS. Now we have ubiquitous virtualisation so lean into it: separate domains. If your user-facing OS only runs in a VM then it doesn't need a filesystem or hardware drivers, because it won't see hardware, only virtualised facilities, so rip all that stuff out. Your container host doesn't need to have a console or manage disks.
This is what we should be doing. This is what we need to do. Hack away at the code complexity. Don't add functionality, remove it. Simplify it. Enforce standards by putting them in the kernel and removing dozens of overlapping implementations. Make codebases that are smaller and readable by humans.
Leave the vast bloated stuff to commercial companies and proprietary software where nobody gets to read it except LLM bots anyway.