As I search my mind for ideas to communicate, and mechanisms to employ in the practice of communication, I am inspired and reminded of the cyclical shape of communication by reading sources I now measure my sanity alongside:

• Drop Site News
• 404 Media
• Lebanon Bomb Map
• Global Intifada - supply chain map

I'm beginning again, nearly from zero, because I caused some serious messes by launching headlong on the road, in an old camper, burdened under too much load.

The camper is having its engine fully replaced, and here I am in Michigan, rearranging as many cables as I could pack into three bags on the underside of a Greyhound bus, alongside my clothes and drumsticks.

This is an inglorious phase of rebuilding after failure. I hope each day this week I can explain some of my failures, examine how I can address them, and propose a new cycle for communication - one I hope can keep me from such failure modes in the days, months, years to come.

The cycle for communication is one I penned in my notebook this morning, as I paddled a kayak around a lake. If you need to borrow someone's kayak and lake for this exercise, call me when you're next near Michigan.

Communication Cycle:

• Alignment
• Composure
• Practice
• Harness

Each day this week, as I explain my failures, I'm going to explore the phases of this cycle including examples from my business or co-curriculars. I'm sure I'll be embarrased by the end, and also more assured by some measure.

For now, as failures are too numerous to seriously consider, I'll splash some silly concern; I've gone far too long since making a latte, and as you can see the practice is gone from my hands.

Lemonade is AMD-officiated and open-source mechanisms for binding deep-learning models onto AMD hardware, from integrated GPU (on the main CPU dye), to dedicated GPU, to the Neural Processing Unit.

On NixOS, there is a module called nix-amd-ai; here is our usage for the Framework 16.

To begin, the most challenging idea is how an agent, an "LLM server", and accessories such as "tools and skills", relate to one another. Lemonade has guidance on these mechanisms.

Lemonade can be accessed in two modes, because of its design as a locally-resident web app managed through a command-line program.

Mainly, lemonade is a package around the program llama-cpp. I had some issues in my log that originated in llama-cpp, because I needed to specify through the Lemonade web UI that llama-cpp use the "ROCm" backend commonly recommended for AMD on Linux. The llama-cpp link includes guidance for Windows and MacOS.

The link to my issues also includes the crucial --ctx-size option, which I needed to increase so llama-cpp could access enough GPU memory (also called vRAM).

Lemonade's FAQ is a nice place to begin also, as this page is outlined by comprehensive sections for each of lemonade's main concerns, such as tex-to-speech, model setup, behaviors, and hardware.

Direction: Embedded

I'm eager to explore Embedded Lemonade ("half & half"?) - this is made for application programmers, such as I used to be, who decide to bring lemonade onto end-user machines for full-fleet deployments of specialized apps.

Embeddable lemonade brings the full scope of a machine's hardware into the reach of an application engineer - no subscriptions needed.

This can be used to process sensor data in vehicles, for example - the Baltimore Node recently had a visit from a Boeing employee who was looking to process more than 1TB / engine / hour of in-flight sensor readings.

Direction: Full-OS agency

Screenenv, from HuggingFace promises to bring LLM reasoning to a full desktop environment - perhaps the Ubuntu & XFCE pairing can be upgraded, to make use of the Niri desktop that I find more capable.

Direction: Plugins

The Lemonade Marketplace ("stand"?) indexes many popular channels for running your LLM in coding or generative scenarios, and I'm likely going to experiment with the open-source options:

• Dify
• GAIA
• Lemon Zest
• Open Hands
• Anything LLM
• Pi

Pi is a simple, command-line replacement for my current agent program, OpenCode. I expect the changeover to be painless, although I may be adding Pi to the Nix Package Index. Pi also comes with many packages, opening the lemonade stand to more purpose-designed operations.

If some mix of skills and procedures seems to fill your needs, you can encode it perhaps, using tiny-agents, packaged for node-js. This package was included and recommended in AMD's announcement for the lemonade program.

Finally, I suppose I need to learn of all the MCP plugins; on the open web, so many as to need numerous indices, and in language-specific packages (elixir, rust). These mcp layers mean that you can build the core mechanisms of a program in isolation, and arrange a process of the pieces in a more nimble, human-commandable form. For the AMD users on the channel,

I'm considering how to build an app that makes a modicum of sense, in a field of practice that has no discipline and an influx of young eager energy.

How I came to care.

I've been producing apps for around fifteen years, since I last checked. After my sophomore year in college, I spent the summer interning for Microsoft in Redmond, WA. I learned a bunch of bad organizational practices there, began immediately shirking my coding obligations (sorry, I remain unpersuaded that printer drivers in JavaScript is in any manner sensible).

On weekends, I learned to code web apps in Ruby on Rails, and that absorbed me for years through my employment at thoughtbot and Code for America.

At thoughtbot I picked up on the early wave of React, and then spent some months learning the core ES6 language, which I think is really nice, compared to the prior browser language-scape. By 2016 at Code for America, I began my obsession in deployment engineering, because Docker really began changing how apps are released.

This odd mix of skills dangerously increased my confidence; I assumed this was the pinnacle, all there was to know, and that I could bank on being ahead of the game, for the next decade or so. And then from 2016 - 2026, I suffered as much disillusionment as possible.

A former colleague from thoughtbot mentioned Elixir to me when I found her in Richmond, VA one day. She has since become a resident of Belgium and I miss her dearly, although I'm glad for the couple days we found for reunions on the East Coast.

Problem Space

Since learning of Phoenix and Elixir, I have gone through the basics. Really, using Elixir for web purposes doesn't really ...click... for me.

How come? Elixir was made to run on the Erlang base, made by the Ericsson telecommunications company, and used for linking thousands of phone relays to relay voice packets from one phone-handset to another; replacing clunky and laborious switchboards, and designed to minimize collisions or disconnections.

All that is to say, Elixir is supposed to happen at a deeper layer than the web. Using Elixir for web apps is possible, of course, and we have Discord and WhatsApp as primary examples of the possible scale the language can reach. Though... using something so capable to render HTML? Silly. Absurd.

Your choice.

Of course, how you choose to build an app is going to depend on your skills, your planned app, and the code packages you can use to build upon.

In Elixir, the package for building web apps is called Phoenix. Yes, [the package]. Python and Ruby both have macro-frameworks and micro-frameworks, but Elixir really has Phoenix only. People are beginning to discuss this problem. There happen to be more options for desktop gui apps, which is nice to consider as a future career arc.

• Emerge
• Scenic

So, Phoenix became popular and a marginal successor to Ruby on Rails, because of a Phoenix sub-package, called LiveView. LiveView in turn made possible LiveBook, which occupies the same niche as Jupyter. Especially remarkable is how LiveBook has learned to handle Python also.

So, because Elixir became popular for web apps, Chris McCord produced Phoenix and LiveView, and then all of the web programmers decided to bring in as many javascript frameworks as possible. Quick index:

• live_debugger
• live_select
• live_toast
• live_svelte
• live_monaco_editor
• live_react
• phoenix_live_react, perhaps different somehow?
• live_vue, annoying to all Elixir-focused podcast speakers.
• live_charts
• lucide_live_view, and similar packages for differing icon sets.

This is a sample from page one, Showing 1–30 packages of 201 total

I'll pause there, because perhaps you see how these packages are going. Eager coder says "sure'd be nice if my JS app could do more backend", and then copies all of their JS code into a package on hex.pm, a space that should be zoned for Elixir use - JavaScript belongs on NPM.

Old-school programmers may recognize this to be a coupling problem (see also).

Decoupling.

In my opinion, the place where such a solution seems to slip sidelong is simple to see. Phoenix Live View includes a module called Hooks, which nearly implies coupling by name alone.

Hooks.ts is a typescript file that compiles to javascript, which then runs in the browser - if you're on mobile, this means that the ~340 lines of code inside Hooks is running on your phone whenever you examine a LiveView-based app. That's simple enough, only... the purpose of this code is to package up other code and to synchronize it to the domain, the "Elixir Core" program based on Phoenix.

Three hundred lines of browser code is simple enough, and I've used hooks to bring in special UI - a specific calendar element from React. Sure is nice to be able to bind a specific user experience onto a specific back-end data layer.

Only, is this simple coupling any more? Or are we building many bridges, one for each JS package we depend on, repackaging the API from JavaScript through the Phoenix hook module, all so we can call up our database query before sending the user any of the HTML page? Are there too many of these bridges? Are they each a bridge too far?

Basic Shapes, Basic Approach.

Here we are, back at the name of this piece:

Elixir Core, Browser Edge.

Elixir is made to run as a mesh of relays, the "core" of the program. In telephonic phrasing, imagine how often an early telephone customer would have a chance to look at a switchboard. Zero. The telephone users should be able to ignore how their voices are being carried.

Similarly, the switches should probably make no bounds on how the end-user's telephone looks or functions. Our Elixir code should have roughly zero concerns with the packages or components used in the application pages. Besides, Elixir in the browser? More aspirational than functional.

So, as long as the relay and the home-phone agree on the messaging scheme, the packets on the cable, the coupling can relax. This happened, really, in telephony also. Two handsets that enabled encryption could exchange messages, without the relays in the middle able to unscramble them. Later, the relays needed no upgrades to connect internet modems, on the same line; thus the fun AOL dial-up tones, programmed into the CD-roms.

Elixir: choosing a proper dose.

[... more research needed ...]

Browser: Unencumbered.

[... more research needed ...]

As I begin re-launching operand.online, many problems and old pains reappear. I had been ignoring my failed domain for months, because I've been engrossed in occupying a new nomadic residence, my camper has gone from Grand Rapids to Baltimore to Los Angeles, to Baltimore to Chicago to Grand Rapids, this year alone.

I've been finding conferences to go to, although they've been of less use than I assumed. The long hours on the road and hurried composure that I normally embody mean that I'm late to show up and a mess when I do. I'm learning that there are other more sensible methods of spending my days, and this domain is one superb manner of being in many places at once.

Beside my human concerns, I'm spending more energy absorbing the news of global chaos, and I'm sad as each day begins that my sleep has likely carried me through someone elses' tragedy. I'm aligning my business to ending these ongoing and expanding horrors.

Whereas before I used my essays to explore my psychology and relationships, now I am beginning to see how much I had been lacking any purpose. I had a chance to briefly meet and collaborate with 404 Media, I had chances to learn from peers at OpenGovHub, and I am coming to see how my passions are indeed aligned, both to the quirks of my unique education and to the compelling demands of the now.

Rearrange.

I begin by erasing a couple unnecessary pieces of my app's homepage, the summary and the sidebar, and collapse the codebase index; these seem to only occupy space with no purpose.

As I record my source changes I realize that this new deployment machine needs a copy, because I am unable to push my code.

• I double-check that I can access the machine using ssh, to the public ip address.
• I double-check that I opened the router port (UDP 60001) needed by Mosh.
• I've already loaded in some code under share/gram/: nue, nux, mech, and pool. These are my baseline programs that I can use to quickly push programs into place.
• mkcd share/gram/op; c init on the domain machine.
• on local, cd share/gram/op; c r set-url share nixos@<public-ip>:share/gram/op; c k
• check that gram:op has a basic public copy.

Preliminaries: loading baseline code.

A number of days ago I breezed through some preliminaries on this machine.

I've already loaded in some code under share/gram/: nue, nux, mech, and pool. These are my baseline programs that I can use to quickly push programs into place.

Here's how this happened; these are copied from a raspberry pi's ~/.bash_history and ~/.config/nushell/history.txt, as I ran through a similar process.

These logs are redundant because many of the commands failed, and needed to be rephrased or re-run after changing a config. They are here so a full and more concise deployment guide can be made someday, by slicing through to the core commands.

          git diff
sudo rm -r /etc/nixos
sudo ln -s /home/nixos/.nux /etc/nixos
nix flake update
hx ~/.config/nixpkgs/config.nix
mkdir ~/.config/nix/
mkdir -p ~/.config/nix/
hx ~/.config/nix/nix.conf
nix flake update
hx flake.nix 
nix flake update
sudo nixos-rebuild --flake /etc/nixos/#pebble
sudo nixos-rebuild --flake /etc/nixos/#pebble build
ls -alD /etc/nixos
cd /etc/nixos
sudo nixos-rebuild --flake .#pebble build
hx flake.nix
hx cell/pebble/index.nix 
sudo nixos-rebuild --flake .#pebble build
ls /dev/disk/by-uuid/
hx cell/pebble/index.nix 
sudo nixos-rebuild --flake .#pebble build
hx cell/pebble/index.nix 
sudo nixos-rebuild --flake .#pebble build
sudo nixos-rebuild --flake .#pebble switch
hx .
sudo nixos-rebuild --flake .#pebble switch
hx .
sudo nixos-rebuild --flake .#pebble switch
sudo passwd
passwd
sudo nixos-rebuild --flake .#pebble switch
reboot
nix-shell -p elixir --run iex
hop home
ls .nue
nix-shell -p elixir --run iex
nix-shell -p elixir --run iex
ls -a
date
wget https://share.operand.online/gram/nux/?download=tar_gz
nsh wget wget https://share.operand.online/gram/nux/?download=tar_gz
nix-shell -p wget --run wget https://share.operand.online/gram/nux/?download=tar_gz
nix-shell -p wget --run 'wget https://share.operand.online/gram/nux/?download=tar_gz'
nix-shell -p gnutar --run 'tar -xzvf ./index.html?download=tar_gz'
mv nux .nux
nix-shell -p wget --run 'wget https://share.operand.online/gram/nux/?download=tar_gz -O nux.tar.gz'
mv index.html\?download\=tar_gz nux.tar.gz
nix-shell -p wget --run 'wget https://share.operand.online/gram/nue/?download=tar_gz -O nue.tar.gz'
nix-shell -p gnutar --run 'tar -xzvf ./nue.tar.gz'
nix-shell -p wget --run 'wget https://share.operand.online/gram/mech/?download=tar_gz -O mech.tar.gz'; nix-shell -p gnutar --run 'tar -xzvf ./mech.tar.gz'
ls mech
mv nue .nue
ls nue
sudo chown nixos nue
ls nue
sudo chown -R nixos nue
ls -al
ls .nux
ls .nue
ls mech
nix-shell -p wget --run 'wget https://share.operand.online/gram/mech/?download=tar_gz -O mech.tar.gz'; nix-shell -p gnutar --run 'tar -xzvf ./mech.tar.gz'; mv mech .mech
nix-shell -p wget --run 'wget https://share.operand.online/gram/mech/?download=tar_gz -O mech.tar.gz'; nix-shell -p gnutar --run 'tar -xzvf ./mech.tar.gz'; mv mech .mech
rm mech.tar.gz mech; nix-shell -p wget --run 'wget https://share.operand.online/gram/mech/?download=tar_gz -O mech.tar.gz'; nix-shell -p gnutar --run 'tar -xzvf ./mech.tar.gz'; mv mech .mech
rm mech.tar.gz mech; nix-shell -p wget --run 'wget https://share.operand.online/gram/mech/?download=tar_gz -O mech.tar.gz'; nix-shell -p gnutar --run 'tar -xzvf ./mech.tar.gz'; mv mech .mech
rm mech.tar.gz mech; nix-shell -p wget --run 'wget https://share.operand.online/gram/mech/?download=zip -O mech.zip'
hx mech.zip 
ls -al mech.zip 
rm mech.zip
sudo ls /etc/nixos/
ls /etc
ls /etc/nixos/
nixos-generate-config
sudo nixos-generate-config
sudo cp /etc/nixos/hardware-configuration.nix ~/.nux/cell/pebble/machine.nix
cd .nux
git status
nix-shell -p git
nix-shell -p git helix

          

          rm -r ~/.config/nushell; ln -s ~/.nue ~/.config/nushell
ls ~/.config/nushell/
session hop
hx ~/.nue/page.nu
hx ~/.nue/media.nu
atuin init nushell
mkdir ~/.local/share/atuin
atuin init nu | save ~/.local/share/atuin/init.nu
$env.NU_VERSION
hx ~/.local/share/atuin/init.nu
zoxide init nu | save ~/.zoxide.nu
zoxide init nushell | save ~/.zoxide.nu
starship init nu
starship init nu | save ~/.cache/starship/init.nu
nsh elixir iex
sudo nix-channel --add https://nixos.org/channels/nixpkgs-stable nixos
sudo nix-channel --update
ip a
hx /etc/nixos
hostname
x -r
hx /etc/nixos
x -r
x
hx /etc/nixos
h -r
x
rg hypr cell
ag hypr cell
grep hypr
x -r
pwd
ls
c s
clear
ls
nsh elixir iex
sudo nix-channel --add https://nixos.org/channels/nixpkgs-stable nixos
sudo nix-channel --update
ip a
date
date now
zellij action dump-session
zellij action dump-layout
zellij action dump-layout | save ~/.config/zellij/session/home.kdl
zellij attach -c home
hop home
mkdir ~/.config/zellij/session
zellij action dump-layout | save ~/.config/zellij/session/home.kdl
zellij attach -c home
hop home
date now
sudo nix-channel --update
cycle { date now }
sudo nix-channel --update
sudo ntpdate
h
date now
x
date now
sudo ntpdate time.nist.gov
sudo systemctl stop ntpdate
h -r
http get https://python.org
ping python.org
ping nixos.org
ip a
x
iex
which elixir
h
iex
mkcd relay
cd ..
rmdir relay
mix new relay
cd relay
hx mix.exs
iex -S mix
mix deps.get
iex -S mix
mix compile
http get https://share.operand.online/gram/op/flake.nix
http get https://share.operand.online/gram/op/flake.nix | save flake.nix
hx flake.nix
nd mix compile
hx flake.nix
mix compile
nd mix compile
hx flake.nix
nd mix compile
hx flake.nix
nd mix compile
hx flake.nix
nd mix compile
iex -S mix
hx ~/.bash_history ~/.config/nushell/history.txt
x
ip a
x

          

Upgrading Node Packages

NodeJS is infamous for "dependency hell", a condition where a full day or occasionally a week can be expended in researching how packages have been upgraded, and how each package depends on others.

For this essay, i'm hoping to use the collapsible feature of DaisyUI, and I saw that the package had an upgrade. As I tried to upgrade that package, I began seeing myself pulled into a dependency hell loop. Here are the immediate symptoms;

error Invariant Violation: expected workspace package to exist for "eslint"
error Invariant Violation: expected workspace package to exist for "ts-jest"
error Invariant Violation: expected workspace package to exist for "@babel/plugin-bugfix-firefox-class-in-computed-class-key"
error Invariant Violation: expected workspace package to exist for "@babel/plugin-bugfix-safari-class-field-initializer-scope"
error Invariant Violation: expected workspace package to exist for "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression"
error Invariant Violation: expected workspace package to exist for "@eslint/plugin-kit"
error Invariant Violation: expected workspace package to exist for "minimatch"
error Invariant Violation: expected workspace package to exist for "glob"    at invariant (/nix/store/8j2jw3v2vzjl9z4xkw2m9xsqxaxzdw89-yarn-1.22.22/libexec/yarn/lib/cli.js:2318:15)
error Invariant Violation: expected workspace package to exist for "@babel/cli"
error Invariant Violation: expected workspace package to exist for "@eslint/config-array"

Each one of these lines indicates one-or-more runs of yarn install, after changing the dependency index inside gram:op/assets/package.json; each of these errors also required me to head to npm, and search for the missing package so I could include the proper recent version number. This was a failing method, and new problems kept appearing.

I realized a more dominant error was higher in the logs, preceding these "invariant violations": the "unmet peer dependency".

warning " > @babel/plugin-bugfix-firefox-class-in-computed-class-key@7.28.5" has unmet peer dependency "@babel/core@^7.0.0".
warning " > @babel/plugin-bugfix-safari-class-field-initializer-scope@7.27.1" has unmet peer dependency "@babel/core@^7.0.0".
warning " > @babel/preset-env@7.29.5" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-bugfix-firefox-class-in-computed-class-key@7.28.5" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-bugfix-safari-class-field-initializer-scope@7.27.1" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.27.1" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-bugfix-safari-rest-destructuring-rhs-array@7.29.3" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.27.1" has unmet peer dependency "@babel/core@^7.13.0".
warning "@babel/preset-env > @babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs2@0.4.17" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs2@0.4.17" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".warning "@babel/preset-env > babel-plugin-polyfill-regenerator@0.6.8" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs2 > @babel/helper-define-polyfill-provider@0.6.8" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs2 > @babel/helper-define-polyfill-provider@0.6.8" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".warning " > postcss-import@16.1.1" has unmet peer dependency "postcss@^8.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs3@0.14.2" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs3@0.14.2" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".warning "@babel/preset-env > @babel/plugin-transform-async-to-generator > @babel/helper-remap-async-to-generator@7.27.1" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-corejs3 > @babel/helper-define-polyfill-provider@0.6.8" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
warning "@babel/preset-env > babel-plugin-polyfill-regenerator@0.6.8" has unmet peer dependency "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
warning "@babel/preset-env > @babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-syntax-import-assertions@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-syntax-import-attributes@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-syntax-unicode-sets-regex@7.18.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-syntax-unicode-sets-regex > @babel/helper-create-regexp-features-plugin@7.28.5" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-syntax-unicode-sets-regex > @babel/helper-create-regexp-features-plugin@7.28.5" has unmet peer dependency "@babel/core@^7.0.0".warning "@babel/preset-env > @babel/plugin-transform-class-static-block > @babel/helper-create-class-features-plugin@7.29.3" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-arrow-functions@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-async-generator-functions@7.29.0" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-async-generator-functions > @babel/helper-remap-async-to-generator@7.27.1" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-async-to-generator@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-async-to-generator > @babel/helper-remap-async-to-generator@7.27.1" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-block-scoped-functions@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-block-scoping@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-classes@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-classes > @babel/helper-replace-supers@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-class-properties@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-class-properties > @babel/helper-create-class-features-plugin@7.29.3" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-class-static-block@7.28.6" has unmet peer dependency "@babel/core@^7.12.0".
warning "@babel/preset-env > @babel/plugin-transform-class-static-block > @babel/helper-create-class-features-plugin@7.29.3" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-computed-properties@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-destructuring@7.28.5" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-dotall-regex@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-duplicate-keys@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-duplicate-named-capturing-groups-regex@7.29.0" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-dynamic-import@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-explicit-resource-management@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-exponentiation-operator@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-export-namespace-from@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-for-of@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-function-name@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-json-strings@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-literals@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-logical-assignment-operators@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-member-expression-literals@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-modules-amd@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-modules-amd > @babel/helper-module-transforms@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-modules-commonjs@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-modules-commonjs > @babel/helper-module-transforms@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-modules-systemjs@7.29.4" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-modules-umd@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-modules-umd > @babel/helper-module-transforms@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-named-capturing-groups-regex@7.29.0" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-new-target@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-nullish-coalescing-operator@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-numeric-separator@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-object-rest-spread@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-object-super@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-optional-catch-binding@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-optional-chaining@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-parameters@7.27.7" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-private-methods@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-private-methods > @babel/helper-create-class-features-plugin@7.29.3" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-private-property-in-object@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-property-literals@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-regenerator@7.29.0" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-regexp-modifiers@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-reserved-words@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-shorthand-properties@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-spread@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-sticky-regex@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-template-literals@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-typeof-symbol@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-unicode-escapes@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-unicode-property-regex@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-unicode-regex@7.27.1" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-env > @babel/plugin-transform-unicode-regex > @babel/helper-create-regexp-features-plugin@7.28.5" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/plugin-transform-unicode-sets-regex@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-env > @babel/preset-modules@0.1.6-no-external-plugins" has unmet peer dependency "@babel/core@^7.0.0-0 || ^8.0.0-0 <8.0.0".
warning " > @babel/preset-typescript@7.28.5" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-typescript > @babel/plugin-syntax-jsx@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-typescript > @babel/plugin-transform-modules-commonjs@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-typescript > @babel/plugin-transform-modules-commonjs > @babel/helper-module-transforms@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-typescript > @babel/plugin-transform-typescript@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning "@babel/preset-typescript > @babel/plugin-transform-typescript > @babel/helper-create-class-features-plugin@7.29.3" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-typescript > @babel/plugin-transform-typescript > @babel/helper-create-class-features-plugin > @babel/helper-replace-supers@7.28.6" has unmet peer dependency "@babel/core@^7.0.0".
warning "@babel/preset-typescript > @babel/plugin-transform-typescript > @babel/plugin-syntax-typescript@7.28.6" has unmet peer dependency "@babel/core@^7.0.0-0".
warning: Git tree '/home/calliope/share/gram/op' is dirty
warning " > postcss-import@16.1.1" has unmet peer dependency "postcss@^8.0.0".
warning " > ts-jest@29.4.9" has unmet peer dependency "jest@^29.0.0 || ^30.0.0".
warning " > ts-jest@29.4.9" has unmet peer dependency "typescript@>=4.3 <7".
warning " > ts-jest@29.4.9" has unmet peer dependency "typescript@>=4.3 <7".warning " > vite-plugin-babel@1.6.0" has unmet peer dependency "@babel/core@^7.0.0".
warning " > vite-plugin-babel@1.6.0" has unmet peer dependency "@babel/core@^7.0.0".

If you take these ~100 errors, place them in a helix buffer, place a cursor on each line, skim to the third quote, and erase the preceding phrase, you have ~100 lines of only the peer dependencies that are being called for. If you then select the full buffer and run :pipe sort , you can see the minimal requirements:

"@babel/core@^7.0.0".
"@babel/core@^7.0.0-0".
"@babel/core@^7.0.0-0 || ^8.0.0-0 <8.0.0".
"@babel/core@^7.12.0".
"@babel/core@^7.13.0".
"@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0".
"jest@^29.0.0 || ^30.0.0".
"postcss@^8.0.0".
"typescript@>=4.3 <7".

try {rm -r deps assets/node_modules}
nd mix deps.get
nd yarn install --cwd assets
nd mix assets.build

This really did nothing for me; after going through the process I had remaining invariant violations, and my package.json was expanding beyond means.

Before:

{
  "private": true,
  "workspaces": [
    "../deps/*"
  ],
  "dependencies": {
    "daisyui": "^5.5",
    "phoenix": "workspace:*",
    "phoenix_html": "workspace:*",
    "phoenix_live_view": "workspace:*",
    "postcss-import": "^16.1",
    "tailwindcss": "^4.3",
    "theme-change": "^2.5",
    "topbar": "^3.0",
    "vite": "^8.0",
  }
}

an hour in:

{
  "private": true,
  "workspaces": [
    "../deps/*"
  ],
  "dependencies": {
    "@babel/core": "^7.0",
    "@babel/preset-env": "^7.29",
    "@eslint/config-array": "*",
    "@eslint/plugin-kit": "*",
    "@jest/reporters": "*",
    "@tailwindcss/vite": "^4.3",
    "daisyui": "^5.5",
    "eslint": "^10.3",
    "glob": "^13.0",
    "json5": "*",
    "minimatch": "^10.2",
    "phoenix": "workspace:*",
    "phoenix_html": "workspace:*",
    "phoenix_live_view": "workspace:*",
    "postcss": "^8",
    "postcss-import": "^16.1",
    "tailwindcss": "^4.3",
    "theme-change": "^2.5",
    "topbar": "^3.0",
    "typescript": "^6.0",
    "vite": "^8.0"
  }
}

Re-sparking

I rigged up most of my JS-compiler procedure using phoenix_vite, and this package includes an Igniter module to spark the necessary code and configs. I decide to erase the package.json index and begin again.

➜ rm package.json
➜ rm assets/yarn.lock
➜ nd mix igniter.install phoenix_vite

warning: Git tree '/home/calliope/share/gram/op' is dirty
checking for igniter in project ✔
Updating project's igniter dependency ✔
compiling igniter ✔
compile ✔
Dependency phoenix_vite is already in mix.exs. Should we replace it?

Desired: `{:phoenix_vite, "~> 0.4"}`
Found: `{:phoenix_vite, "~> 0.4.3"}`
 [Y/n] n
`phoenix_vite.install` x

Issues:

* assets/vite.config.mjs: File already exists
* Cannot move priv/static/corp/dlcp.cert.pdf to assets/public/corp/dlcp.cert.pdf, as assets/public/corp/dlcp.cert.pdf already exists.
* Cannot move priv/static/corp/2024-04-21.dlcp.png to assets/public/corp/2024-04-21.dlcp.png, as assets/public/corp/2024-04-21.dlcp.png already exists.
* Cannot move priv/static/corp/dlcp.CorpForProfitDomesticInitialFiling.pdf to assets/public/corp/dlcp.CorpForProfitDomesticInitialFiling.pdf, as assets/public/corp/dlcp.CorpForProfitDomesticInitialFiling.pdf already exists.
* Cannot move priv/static/cache_manifest.json to assets/public/cache_manifest.json, as assets/public/cache_manifest.json already exists.
* Cannot move priv/static/corp/CP575Notice_1704499942839.pdf to assets/public/corp/CP575Notice_1704499942839.pdf, as assets/public/corp/CP575Notice_1704499942839.pdf already exists.
* Cannot move priv/static/images/favicon.ico to assets/public/images/favicon.ico, as assets/public/images/favicon.ico already exists.
* Cannot move priv/static/robots.txt to assets/public/robots.txt, as assets/public/robots.txt already exists.
* Cannot move priv/static/images/logo.svg to assets/public/images/logo.svg, as assets/public/images/logo.svg already exists.
* Cannot move priv/static/fonts/fa-solid-900.ttf to assets/public/fonts/fa-solid-900.ttf, as assets/public/fonts/fa-solid-900.ttf already exists.
* Cannot move priv/static/images/screen.png to assets/public/images/screen.png, as assets/public/images/screen.png already exists.

➜ try { rm -r assets/vite.config.mjs priv/static assets/package.json assets/yarn.lock }
➜ nd mix igniter.install phoenix_vite

These folders will be created:

/assets/public


These files will be removed:

* assets/vendor/daisyui-theme.js
* assets/vendor/daisyui.js
* assets/vendor/topbar.js


The following installer was found and executed: `phoenix_vite.install` - Warnings:

* Failed to remove dependency :esbuild from `mix.exs`.

  Please remove the old dependency manually.

* Failed to remove dependency :tailwind from `mix.exs`.

  Please remove the old dependency manually.



These tasks will be run after the above changes:

* deps.clean --unlock --unused esbuild
* deps.clean --unlock --unused tailwind
* assets.setup

Warning! Uncommitted git changes detected in the project.

You may want to save these changes and rerun this command.
This ensures that you can run `git reset` to undo the changes.

Output of `git status -s --porcelain`:

 D assets/package.json
 D assets/vite.config.mjs
 D assets/yarn.lock
 M config/dev.exs
 M config/prod.exs
 M config/runtime.exs
 M flake.lock
 M flake.nix
 M lib/op_web/live/chronicle/show.ex
 M lib/op_web/router.ex
 M lib/render.ex
 M mix.exs
 M mix.lock
 D priv/static/images/logo.svg


Proceed with changes?
 [Y/n] y
Resolving Hex dependencies...
Resolution completed in 0.274s
Unchanged:
  bandit 1.11.0
  cachex 4.1.1
  call 0.0.2
  db_connection 2.10.1
  decimal 3.1.0
  dns_cluster 0.2.0
  earmark_parser 1.4.44
  eternal 1.2.2
  ex_ast 0.11.2
  ex_doc 0.40.2
  ex_hash_ring 6.0.4
  ex_heroicons 3.1.0
  expo 1.1.1
  file_system 1.1.1
  finch 0.22.0
  floki 0.38.1
  gettext 0.26.2
  git_cli 0.3.0
  glob_ex 0.1.11
  hpax 1.0.3
  igniter 0.8.0
  jason 1.4.5
  jumper 1.0.2
  live_debugger 0.3.2
  lumis 0.5.0
  makeup 1.2.1
  makeup_elixir 1.0.1
  makeup_erlang 1.1.0
  mdex 0.12.2
  mime 2.0.7
  mint 1.8.0
  nimble_options 1.1.1
  nimble_parsec 1.4.2
  nimble_pool 1.1.0
  owl 0.13.0
  phoenix 1.8.7
  phoenix_html 4.3.0
  phoenix_html_helpers 1.0.1
  phoenix_live_dashboard 0.8.7
  phoenix_live_reload 1.6.2
  phoenix_live_view 1.1.30
  phoenix_pubsub 2.2.0
  phoenix_template 1.0.4
  phoenix_vite 0.4.3
  plug 1.19.1
  plug_crypto 2.1.1
  postgrex 0.22.2
  req 0.5.17
  rewrite 1.3.0
  rustler_precompiled 0.9.0
  sleeplocks 1.1.4
  sobelow 0.14.1
  sourceror 1.12.0
  spitfire 0.3.11
  telemetry 1.4.2
  telemetry_metrics 1.1.0
  telemetry_poller 1.3.0
  text_diff 0.1.0
  thousand_island 1.4.3
  tox 0.2.3
  unsafe 1.0.2
  websock 0.5.3
  websock_adapter 0.5.9
  yamerl 0.10.0
  yaml_elixir 2.12.1
  yaml_front_matter 1.0.0
All dependencies are up to date
** (File.Error) could not remove file "assets/vendor/daisyui-theme.js": no such file or directory
    (elixir 1.18.4) lib/file.ex:1222: File.rm!/1
    (elixir 1.18.4) lib/enum.ex:987: Enum."-each/2-lists^foreach/1-0-"/2
    (igniter 0.8.0) lib/igniter.ex:1253: Igniter.do_or_dry_run/2
    (igniter 0.8.0) lib/igniter/util/install.ex:211: Igniter.Util.Install.run_installers/5
    (mix 1.18.4) lib/mix/task.ex:495: anonymous fn/3 in Mix.Task.run_task/5
    (mix 1.18.4) lib/mix/cli.ex:107: Mix.CLI.run_task/2
    /nix/store/4nvnygngnha29ycn4lilh5iazc6hikff-elixir-1.18.4/bin/mix:2: (file)

So, an error appears after much helpful guidance. good enough. obey guidance.

I check mix.exs and see there is no dependency on esbuild or tailwindcss. odd. Maybe my dependencies are old.

➜ try { rm -r deps }; nd mix deps.update --all
➜ try { rm -r assets/vendor assets/vite.config.mjs priv/static assets/package.json assets/yarn.lock }; nd mix igniter.install phoenix_vite

This final error occurred again,

** (File.Error) could not remove file "assets/vendor/daisyui-theme.js": no such file or directory

so I added some quirky placeholder-insertions into my command:

[ assets/vendor assets/vite.config.mjs priv/static assets/package.json assets/yarn.lock ] | each {|n| try { rm -r $n } }
[ assets/vendor/daisyui-theme.js
] | each { mkdir ($in | path dirname); touch $in; }
nd mix igniter.install phoenix_vite

This also failed.

Why was I doing all this?

I remembered the reason - I planned to make those code snippets above accordion-able. This is not worth the hours of dependency upgrades. I was miserable and pulled in so deep.

One source of my misery here is that I am currently supposed to be in DC; these computer upgrades have had me pegged to the desk for 24 hours longer than planned, and there's more hardware issues to address before I go. I need to pull back out of this unplanned upgrade cycle.

Undue.

I run c co -b vite, making a branch for my changes. I run cap, my alias for git add -p.

Anything to do with these dependency upgrades goes into the branch.

I commit, then change back to main. Clean branch.

As I try to rebuild again and reclaim the normal experience, I see a line inside mix.exs for installing dependencies. yarn install --production.

I run:

nd yarn install --cwd assets --production

Success. Goddamn, one missing option this whole day.

Resume, deploy.

So, up and running locally. Yay? Seems like a small consolation. Now I need to log on to the lab and proxy the code to the domain.

Begin by seeing if I can push the changes, to [gram:op] and [gram:page].

I had some code to help on this, inside [gram:nue/gram.nu] (naming issue?) though that's basically useless now, obscured through many broken layers.

➜ c r set-url share nixos@76.112.8.171:unshare/page
➜ c k share
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 24 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 548 bytes | 548.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0), pack-reused 0 (from 0)
remote: error: refusing to update checked out branch: refs/heads/main
remote: error: By default, updating the current branch in a non-bare repository
remote: is denied, because it will make the index and work tree inconsistent
remote: with what you pushed, and will require 'git reset --hard' to match
remote: the work tree to HEAD.
remote:
remote: You can set the 'receive.denyCurrentBranch' configuration variable
remote: to 'ignore' or 'warn' in the remote repository to allow pushing into
remote: its current branch; however, this is not recommended unless you
remote: arranged to update its work tree to match what you pushed in some
remote: other way.
remote:
remote: To squelch this message and still keep the default behaviour, set
remote: 'receive.denyCurrentBranch' configuration variable to 'refuse'.
To 76.112.8.171:unshare/page
 ! [remote rejected] main -> main (branch is currently checked out)
error: failed to push some refs to '76.112.8.171:unshare/page'

I'm in Michigan again, after being engrossed in the proceedings of the 2026 Code for America Summit in Chicago. The main lesson? Where government meets technology, there is only room for CEOs or politicians to speak up. The old party, -on'line.

The corollary to this lesson seems to be, that there is no place to mention the foreign or domestic humanitarian implications of the current US federal policies. No mention of our national commerce in munitions, or aggression aimed at the ruling bodies of neighboring peoples. No dialogue to address policies, only to accomodate their implementation.

Here's some background on my relationship with the organization; copied from my recent cover letter to them in an application from January.

I remember the long run of Wednesday nights that I spent at CfA headquarters in SoMa, before I ever applied to be a fellow, pushing along on the program at Code for San Francisco (now called SF Civic Tech). The next year, as a fellow in Seattle, we had a chance to speak to Open Seattle. Years on, I checked in on Code for Philly. They turned me away that night, because I had forgotten to bring my vaccination card. Ironically, by then my vaccination card was being signed by a medical officer in the House of Representatives.

Zoom into the middle of that span, though - and during the pandemic I also honed in on Chi Hack Night, and Lansing Codes. This was a challenging moment for all of us, because the organization where we had found a home seemed to be closing the doors on its most public forum, the brigades. I had one good idea of what could happen, though none of us had any idea of all that would.

More than any other group, Code for America had seemed like a philosophical approach; their name appears to command, or demand, the action they seek. "Code, now! for America!"

Now, rather than being read as an order, their name displays as a menu, only a single option: "Code, for America, from Anthropic AI. Constitution included, deliberation unnecessary."

Code for America announced their recent partnership with Claude; and I am saddened beyond measure to see the consequences clear as day.

CfA has become a handy vehicle, a ship, to package and bundle through the procurement issues for municipal, state, and federal agencies seeking access to AI products as a guarantee for early, phased-in retirement. Now, the AI that Anthropic has been selling is going to be packaged cleanly, in vibe-coded and tailored-to-size apps for one purpose or another; from food aid to, someday, automated evictions; including those conducted at gunpoint, or remotely by missile.

"The strategy is delivery", after all, in a nation whose primary product is munitions.

How much is able to be cleanly disposed of, brushed under the rug of "AI policy"? How many people shall be disenfranchised from an education in the nuances of policymaking, and equally so from learning of the machinery that is here to replace policymaking?

There had once been room for the audience to draft plans; now we are asked to calmly take our chairs in the lecture hall. How many of these people, barred from taking action to care for their future in a direct manner, aching from the numbness of shepherding inhuman agents, discouraged from composing a real decision when a machine could describe a similar one, are going to finally be eager for the role-model guidance they've so far been lacking, when it lands upon them in the form of a military draft notice?

Through the many main-stage discussions, rather than dialogues, a common theme had been how to "catalyze and scale our impact"; how some people were still "searching for a magic bullet"; how to measure the consequences when "an impact lands". Nobody seemed to notice that this language is an echo of the explosions, produced and sold by US companies as clean, slick, packaged missiles, aimed at people also disenfranchised by their rulers. Perhaps the "catalyzed reactions" our conference leaders are searching for happens to be the white phosphorous being deployed in Lebanon by Israel, our supposed national ally.

My problem with Code for America has been their lack of public engagement. Before 2021, the organization had been a hub of discussion through the nation, because of the local brigades who circulated ideas day in and day out. When Jennifer Pahlka handed the reigns over, and the organization decided to abandon their grassroots base, they became fully closed to ideas from the public. There seemed to be a cost-benefit decision at play - the cost of moderating discussion boards full of active engineers seemed to surpass the benefit of a thousand considerate and concerned coders, thoroughly embodying the mission of the organization, engaging in local action in hundreds of municipalities - in and beyond the USA.

Sadly, this could be flipped around easily. Bring an engineer rather than a CEO onto the stage, and we may be reaching through to the demands and clear direction that solidarity groups have been promoting for decades, normally unheard: open access to the means of production.

In this hype cycle, AI is the product; the means of production is access to the underlying, open-source mechanisms:

• the vector databases,
• the encoding models,
• the decoding models,
• the tokenization models,
• the similarity search engines,
• the graph databases for mapping knowledge,

the many pieces whose "sum of the parts" is called AI, though which each in measured additions or absence in a product form the desired recipe that is called for on one occasion or another. An example? You can make more humane decisions by handing a case-manager direct access to a knowledge graph (basically imagine Notion or AirTable), rather than obscuring the facts of the case through an encoder (email correspondence -> assumed facts), and a decoder (recorded facts -> assumed conclusion and irrevocable consequence).

The one session I did find some solace in though, was the discussion of the group collaborating with IRS direct file; they open-sourced their "fact graph" of dependencies for IRS tax return forms. For more research and open-source programming along those lines, see PolicyEngine.

I made a small proposal to a colleague in the first breakout room of the conference, to examine how often we would hear the phrase "AI" compared to "vector database"; the concluding ratio was as predicted, many-to-zero.

These CEOs charging headlong into the camera lens on stage know that their product is made of a delicate balance of internal mechanisms, that a small shuffle from one direction to another, a dialing in of temperature, can produce the difference between a swell of emergency housing response and a cascade of evictions when people become a problem. The logic of resettlement can be run from a single dial: "Population from 11 to 3, please."

This experiment has played out before, during the election cycle for John F Kennedy, in a corporation called Simulmatics. Simulmatics built a "People Machine" for the 1952 presidential election, which predicted the electoral consequence of polling inputs.

Our modern "People Machine" goes much deeper than polling numbers - it has a full model of the language used to relate and grasp hold of our emotions. How real can this "People Machine" be when making humane decisions, and how shell-shocking the consequences when they fail to comprehend that the've been raised, and hired, in the absence of humanity?

Contasia, Arlene, Amanda;

I'm on the road to DC and then NYC today after Chicago. I had been either been eager or dreading the summit for months, and I'm sorry to see how the days played out.

My paranoias played a serious role, of course, and my physical exhaustion and lack of company. There seem to be few friends remaining after so many years of changes.

Your organization's productions are emotionally charged for me, especially once again seeing old partners-in-crim(inal justice) amplifying messages that seem designed to keep people in their proper camp.

I hope this opens discussion, and I hope to begin helping those left behind. https://operand.online/chronicle/cfa.2026

To begin a dialogue, if you choose to respond, I'd ask how government is "for the people, by the people" - if the only programming skills on the menu are "Discrete Logic 211" fact-graphs, and the user manual collection for Anthropic products?

I'm glad to see your user researhers are reaching new depths in the Grand Canyon, though for us subscribed to the Baltimore PD's media relations list, the daily shooting briefings imply we cannot do so much to  keep our heads down.

If your purpose is to ensure policies are delivered as ordered, please consider how damnable those orders can be.

(Once again,)
Peace,
Calliope Y

in Proton Mail,  confer@operand.online
in Signal,       c4lliope.**
in secure,       202-***-****

Legal research in the USA is fully dependent on two products; Lexis Nexis and WestLaw - these both use incredible fees to keep out small business and independent researchers, in essence producing a scarcity of the most crucial resource in any democracy: a basic comprehension of the legal rules of the game. Layers of academia and law have been designed to guard access to these resources, and in recent years we are all feeling the consequences - money alone buys access to the rulebook.

These companies build their program fully on public records, sourcing from the Library of Congress, GovInfo, the Code of Federal Regulations, and Harvard's more recent CaseLaw Access Project. These public records are the original framing of open-source; the public needs to access and learn from these same sources to either comply, or to change the rules that bind us.

See how simple web scrapers and advanced databases combine into an open-source replacement for the legal gridlock we're used to, and learn how to connect directly behind the scenes at Congress to the people publishing these records each day. This HOPE talk marks the release of a new public legal search engine - open source from the homelab hardware to the public records request.

Speaker Bio: Calliope Youngblood

Calliope has learned from a decade of experience including SF startups, national nonprofits, city governments, and the office of Clerk of the House of Representatives.

They were hired to the Clerk's office based on a prototype of this talk's app, made five years ago during a more sane administration. Since being fired by the Clerk for "too many prototypes" in 2023, Calliope has focused on running apps from home - using NixOS, NuShell, Elixir, and Rust. Each of these play a role in this open-source research program.

In 2026, Calliope is conference-hopping in a camper van as a cyber nomad, exploring hacker spaces and feeding open-mic musicians.

Appendix (the problem is real!)

"Search charges range from $0 to $469."

• LexisNexis "Law Firm Per Search Pricing"

Basic pricing reference for one user:

• Lexis Nexis ($150/mo)
• WestLaw ($1210/mo)

( ideas licensed public domain / product of https://operand.online )

@kura - splendid issue to raise; this is the main reason I'm focusing on the import_export module before I find my app in a bind.

My search for a db began from a blog post by fjall: https://fjall-rs.github.io/post/recreating-webtable The fjall blog made me see the mechanisms of LSM trees more clearly, and this page specifically emphasized how practical they can be for page indexing.

I feel like a small package in Rustler could be able to locate a fjall db on disc, and use a query to load a subset into a khepri db. Elixir could use the shared khepri store to coordinate across nodes.

Perhaps khepri should be used only for "receipts" of scraped pages -

@example.com/addr/@cache -> @example.com/addr/@2026-04-15_12-59-59
@example.com/addr/@2026-04-15_12-59-59.hash -> <hash>
@example.com/addr/@2026-04-15_12-59-59.api_key -> <key>
@example.com/addr/@2026-04-15_12-59-59.module -> Scraper.ExampleCom

So, how to bring the scraped pages from the nodes, back into fjall? seems like this could easily be RabbitMQ / Broadway / plain old Elixir.

The full process is

0. spin up cpu-node and connect to disc-node.
1. cpu-node queries for a record to process.
2. disc-node loads record receipts -> fjall (in rustler) -> khepri.
3. cpu-node checks receipts, enriches original record.
4. rabbitmq sends enriched fields back to disc-node.
5. disc-node pushes records & receipts to fjall.

In 1. and 3., the same query could be used to decide if the enriched keys are added to kehpri; this is an optimistic-update that khepri can use to keep nodes coordinated. for example, links between pages and their associated keywords & addresses. this could mean other nodes in the cluster could do downstream processing based on keywords like "github".

This general approach means that many small khepri clusters should be able to sync off of the same fjall db, where each khepri cluster is using a group of queries designed for that cluster's unique purpose. This semantic-partitioning seems like it could keep memory use small even for complex domains.

I've been coding since my first year of high school, in 2005. No day in any of those 20 years has been spent on vibe-coding.

I imagine this solid run of legacy coding practice is going to end soon, because I do see the use of using LLMs for learning a new language, and I have a clear idea of my needs as I approach Rust. I'm on pace to make it through the Rustlings course this weekend, and the language has nice guard rails; I'm confident that I can guide the language model in proper directions.

Though there has been no vibe coding, there has probably been too much "crucial rush" coding. Readers realize I am eager to speak about my homelessness and nomadism, and these scenarios mean paring down the energy I spend on my cyber practice. Looking ahead now that I am in a proper camper home, I am making too many promises to be so lacksidasical any more.

I've recently circled back up with colleagues at Open Gov Hub, where I made my third or fourth round of promises to put case.law to use.

During the Congressional Hackathon -- with only a small break to heckle and curse Michael Johnson as he hoarded the stage and microphone to announce the House's succumbing to Microsoft's AI expansion -- I produced a scraper for the case law documents, and began to pull the corpus.

That scraper was made in [NuShell] and had been called domain.nu; later on I pulled the logic into index.nu, to add logic for processing documents from the DoJ's Epstein document releases. I acquired documents from the original dump, breaking the case.law parser in the process, and made no progress in processing either record corpus in the ensuing weeks, wherein I was finding shelter from blizzards and shuffling broken cars around (as legally as possible) in three states.

So I've long been burdened by barely-good-enough processes that are simply holding me back.

The final mishap came last weekend, after I had spent four days in Baltimore during the blizzard, learning the basics of solar camping under layers of ice, and running to the camper for 15 minute spells before my fingers began to ache. I had a good many hours in the Baltimore Node, where I definitely kept from closing my eyes for too long on the new comfy couch. I also lost a good many hours of sleep in the process, and am realizing that recovery from sleep debt carries symptoms much like depression.

All the same, I finally packed up from Baltimore on Friday, and headed to George Mason University to join into the Global Game Jam. I had big ideas on Friday night about how to approach the theme, "Mask". As soon as I logged on, Saturday morning, I checked and could see that my domain failed to respond.

No one shall ever be able to say for sure if this is a case of corporate espionage or sabotage, because the small miniPC that I had been running my domain on from the minimal security on-premise shelf at Baltimore Node had once again had the power strip kicked or nudged or plucked. This seems to have happened on three occasions, always when I leave Baltimore after a long coding session. When I finally end up where I need to be, I find that the computer has gone offline, and I need to come to grips with my lack of a recovery option.

So, I've long been ready to upgrade.

Here's a quick summary of the problems and security lapses I can recall in this moment.

• [ ] crucial .nu code has no specs or test harness.
• [ ] the elixir app has no specs or tests.
• [ ] the elixir app has no solid road map.
• [ ] the MicroVM deployments can only handle a couple of hand-spun apps.
• [ ] the Resource Guide has broken and is basically disengaged.
• [ ] I am the only user; maybe I need to examine open-source auth
• [ ] miniserve has likely had no security appraisal.
• [ ] my main coding machine had passcode-based SSH access enabled for 1-2 months.
• [ ] I did nothing to sign my git commits.

There's more to say, tho I became distracted by making the diagram at the beginning of the page.

All of these problems began making me anxious, so I had to think ahead. Sorry if you read through all of this, some days simply is nice to spill your mind.

I do think that diagram's going to help tho, I'll see how much of that I can make use of next week.

“Static Site Generation” is the process of rendering html from a codebase, where you can describe the pages succinctly using humane markup languages like Markdown. They are more secure than Wordpress or other dynamically-rendered content management systems, because any changes require access to the source code - in our case, permissions in the GitHub org. This thread is a place to explore libraries and themes.

Before the library dump, I should include that we could do interactive elements through iframes, including the popular giscus and utterances. These need nearly no management and can be easily moderated through GitHub issues; basically making our GitHub codebase a public discussion running parallel to this forum.

So, choices.

Zola builds domains using Rust. Some of these themes are more for blogging, but I think you may like some.

• serene
• zola-theme-nivis
• tanuki
• terminus
• zap
• apollo
• boring
• pico
• papermod
• zola-theme-terminimal
• juice
• shadharon
• papaya
• zola-386

Hugo is an option using Go (of course) (Themes)

• Newsroom has a nice look

Lume is popping up in the Deno land. (Themes)

Docusaurus is based on simple and approachable ideas, designed for readable guides.

Gatsby is Javascript & React. Discouraged, because things seem up in the air during an acquisition.

NextJS is popular, had a full hype cycle.

Quartz is like a knowledge base similar to Obsidian, but public on the web. Could be plugged on top of a wiki or some such arrangement.

Quarto is more for data dashboards, probably beyond scope. Same for Framework.

Deploys

GitHub can handle all of the publishing for us using GitHub actions; this takes less than an hour to set up, and then you never have to think of it again. If you do have to make changes, it’s easy to find people who have used it or can pick it up quickly.

Deno Deploy is a new option that is based on similar principles, and is designed for Lume or Fresh (below). I helped a friend deploy here once, and the process had been easy as can be. Requires a credit card on file for antispam purposes; their free plan is the most generous I’ve seen. They also support dynamic-rendered apps, which brings us to…

Bonus: Dynamic Rendering

I’m already dumping links, so here are directions to look if we outgrow SSG.

• WikiJS is a fully managed wiki with a one-line deploy. I’d recommend upgrading our wiki to this soon. Has serious benefits for content management.
• DataStar
• HTMX
• Deno Fresh
• Astro

0. Sidebar:

As you may see, a rogue sidebar appeared!

See dialogues concerning Nex; a minimal Elixir package seemingly able to speed up our production process. Many of these plans are going to be made using new approaches based on Nex.

Now, here are the planned modules to be added, already marked by sidebar placeholders.

1. chronicle

The main experience you already recognize. Much of the logic behind these essay pages is included in the Source.Page module, which makes it simple to pull into Nex someday.

That said, there is no hurry to do so. I'm going to bypass this migration, until Nex is already up and running for some of the pending pages.

One odd coincidence that I learned today is the similarity between my approach, and something from Ruby called Postwave; both approaches read the file using a preconfigured package, and the application logic has full reign to reshape the source as needed before the page render.

Since Postwave seems to be a success, perhaps you'll see our approach packaged into a hex dependency, so others in the Elixir space can make equal use.

2. dialog [pend]

Look here, we already needed a link to another domain so you could read up on our plans to use Nex!

I'd like to be able to discuss things openly on forums across the web, with no concerns for "syndicating" (linking, or copy-pasting) to this domain.

Luckily, many of my discussions happen on Discourse, and there is a premade channel for subscribing to my actions. Similarly for GitHub issues; I can use the GraphQL scheme to query the precise records needed.

3. org mode & 4. people [pend]

You should realize I do research; I go more broad than deep, like so.

I have [some grand aims] for linking ideas across cyberspace into a large graph database using Rust and the Cypher query language. Perhaps I'm only eager to appear someday on Andy Pavlo's annual db roundup.

I'm going to begin some much scrappier approaches, using .yml and cachex, to produce an explorable index of organizations and people similar to SPLC's extremist index, only for cyberspace!

In gram:nue, page dump is a simple, reliable command designed to produce a .yml backup of all pages open in my browser. I'd like to begin depending on this as a daily source of leads, each of which are then processed through a series of scrapers and mungers.

There's many directions to explore here, so as soon as those addresses are cached inside the app, I'll begin displaying them and discussing how to enrich the resources.

5. gloss [pend]

Look up in #2 - I had to describe the process of "syndication", which makes sense to you already if you do journalism or production, and perhaps is a new idea if you are a casual online denizen.

I see many examples where jargon holds up discussion, and I'd like to fully re-organize how jargon is used; imagine a pop-up mechanically similar to nutshell.

A primary aim is that using jargon should do nothing to hold up the essay process; I should be able to simply mark a phrase as gloss-arizable, and then upon publishing, see a queue of phrases that need description. This process is inspired by numerous examples of language-translations for apps.

Please bookmark ToS;DR. This is one of your main search engines this year.

Specifically, you are looking for rules in the theme of "data brokerage"; rules such as:

• Amazon's "Voice data is collected and shared with third-parties",
• Facebook's "Deleted content is not really deleted",
• Apple's "Your personal data may be disclosed to comply with government requests without notice to you",
• Reddit's "Tracking via third-party cookies for other purposes without your consent.",
• YouTube's "This service can view your browser history",
• Quora's "They store data on you even if you did not interact with the service",
• PayPal's "This service still tracks you even if you opted out from tracking"

These are only chosen from the homepage! You're responsible for searching the apps you use. Ignorance may be a popular excuse, but when apps sell your data, these are the buyers.

To begin, I use Brave.

Brave is more secure than normal; imagine Chrome with a bunch of the Google ripped out. This means any Google plugin runs in Brave.

Also, Firefox copied the plugins from Chrome, so you can probably find the same plugins in their web stores.

You may see plugins called "extensions"; that's a hairy issue.

Here are the plugins I use daily.

• uBlock Origin

  Blocks so many ads that some days I forget that most people still have ads. Also keeps me from clicking through on some clickbait.

• ToS;DR

  If you pin this to the menu bar, you'll see an A -> F letter grade for each domain. Click to read the main concerns before signing up, or flushing your cookies and running.

• Vimium (source)

  Move around and through pages using your keyboard alone. The mouse-to-keyboard loop is gradually breaking your mobility, so load this up and press ? on any page to see your new commands.

• Proton Pass (sign up!)

  You need a password manager that has encrypted sync, and your browser's built-in one is a cheap replica. As you use Proton Pass you'll be pleased to see the pop-ups for "passkeys", which enable one-click, no-pass logins.

• TabFS

  For the real hackers in the audience, because this plugin requires moving some config files around. When you're done though, you'll see a local file share that mirrors the open tabs in your browser. This plugin encouraged me to change from Firefox -> Brave, because independent plugin management is simpler in Chromium. Omar's one-page explanation is superb.

In 2026, there are some amazing programs being made by genius coders, who are happy to hand out their code for free so that people can be sure of their security.

One such program is Jitsi - their biggest offense in my book is their name, which is hard to say is or is not really offensive.

This group of coders made all good decisions. One, they open-sourced their code so that people can be sure of their security.

Using the in-browser model familiar to anyone who has used Google Meet, you can be sure that you are able to manage the permissions that the app is asking for from your machine; microphone, sure! camera, maybe another day. files, hell no! Because you already are using a browser now, you know you can be on any call in a couple quick clicks.

People say Zoom is secure, but nobody knows this! Any app that claims to be end-to-end encrypted needs to share their code if they aim for their claim to be credible. In 2025, the rulebook changed in many crucial places; if we are unable to rely on our health insurance companies to keep our records secure, who seriously imagines that unimaginably young, unimaginably rich coders are going to handle the vault keys properly?

...and, they don't even claim to! Reading through their policies, you only have to go a few paragraphs before you see that they group their users into two camps; their super-special paying organizations, which have the threat of legal action on their side, and the large mass of casual users, who share reunions, medical discussions, holiday celebrations, and phone sex.

Coders are creeps!

Yes, I am also a creep. Of course I am! I code online! And I know precisely how much I could access if I cared to look. The difference is that I'm a smidge more scientific, much more self-obsessed, and uphold a really unique philosophy around commercial success.

To me, success in 2026 is being able to keep a goddamn secret! Is being able to choose which business you share, and which you share with specific people!

So, I'm going to pass on your creepy-ass Zoom calls! If there's one that I really need to be on, I'm going to spin up a VM on my computer so that it has no idea of the other files laying around, such as my ~/passcodes.csv. If you are such a negligent bullhead as to get me onto your call, you'll be unable to see me because my VM cannot access my camera! By design! Same for my microphone, so I'll plug in a USB mic if I really need to speak up. More likely than not though, I'm exhausted by now. I'll spend the full duration of the call eeking a small echo of pleasure from the continuation of this rambling alarm, for your sheepish audience to rub their enablist shame in.

And if we're really lucky, we'll still have something to talk about by the end, so I'll follow along to your marginally-less harmful Slack or Discord channels, where I'll keep. name. dropping. Jitsi.

Please remember that our holier-than-health Zoom took the world by storm in the middle of a panicked response to an airborne toxic event!

No one read the conditions back then, and those conditions have changed on numerous occasions - each - year - since then.

Here's where those conditions are now, according to ToS;DR. There are so many angry red data horrors that the following green "You maintain ownership of your data" is seriously the most disrespectful sentence I have ever come across. That's so goddamnfuckingbumasshurt meaningless!

Here's some big ones:

• This service may collect, use, and share location data
• This service gives your personal data to third parties involved in its operation
• This service may keep personal data after a request for erasure for business interests or legal obligations
• The service may sell your data unless you opt out
• This service forces users into binding arbitration in the case of disputes
• The service may use tracking pixels, web beacons, browser fingerprinting, and/or device fingerprinting on users.
• This service gathers information about you through third parties
• You waive your right to a class action.
• Your personal data may be used for marketing purposes
• Instead of asking directly, this Service will assume your consent merely from your usage.
• The service uses your personal data to employ targeted third-party advertising
• This service gives your personal data to third parties involved in its operation
• Your data may be processed and stored anywhere in the world
• Any liability on behalf of the service is only limited to the fees you paid as a user

Many of the "green thumbs" are meaningless when combined alongside the red alarms. Compare:

• You can request access, correction and/or deletion of your data
• This service may keep personal data after a request for erasure for business interests or legal obligations

If you really need to see me so exposed, find me at the local sex club. If you need me on board for your cause, begin securing your business.

Goddamn.

2023

Loose Ends

In Jan 2023, my role at the House of Reps Clerk's office ended. I had been calling for in-house program design and building many experimental programs, some of which are being used today, and all of which I found far more engaging than the assignments.

On the side, I had a hodgepodge of apps running, so I could explore new languages and approaches. I had a far-too-broad aim of building a search index for legal sources.

Fresh Leads

During that summer I reconnected, briefly, with a former colleage in nearby Richmond. She explained the ideas behind Elixir, and this seemed like a good change of pace from Ruby + JavaScript. I began gradually rebuilding my core apps from Ruby to Elixir, and shared the ideas at a "Pitch Labs" group for local independent businesses.

I engaged with the local hackerspace, where I had become secretary. I spent many days speaking with one of the members, a gamer who had more home-lab experience, who talked me off of my raspberry-pi bundle and onto a real [ProxMox] deployment. I quickly used the VM management therein, to deploy many programs I designed and produced, alongside:

• ProxMox
• Mailu
• Gitea
• Penpot
• Passbolt
• Livebook
• Wiki.js

Side Missions

HacDC had been abuzz that year - we had a spinoff group called hyperdemocracy inspired by the earlier assembled app I had produced. The Hyperdemocracy bunch ran an 8-hour public-library hackathon, where around a dozen coders learned to use LLMs on federal legislation.

Other HacDC members had been explaining NixOS, and it took me until October to pick up the charge and make the change. I managed to change the nixpkgs recipe for Elixir, before the 23.11 release window - my first month! This change helped me compile Elixir as a mobile app on Android, in a proof-of-concept app that for a global hackathon.

That same fall, I had my first (and only) Elixir commission. I charged next-to-nothing, if you know the industry rates, because my friend needed the app and I needed the practice. All along, I had been checking off my learning aims for the year.

2024

Long Haul

The one remaining language I had aimed to learn in 2023 had been Nushell. I began picking this up in January 2024.

I found the experience far nicer than onboarding to any other command line, although I really could have used more guidance in the form of screencasts; I really like the small episodes of railscasts and elixircasts, and I feel that now I'm finally in a place to begin producing these.

Spiraling

I also began that year by filing for a business, Operand Company. Looking back, I had no business running a business. When I heard back about the incorporation in April, my first week became a hellish sequence of slip-ups.

• PayPal dropped my business and perma-banned me for concerns of money laundering.
• I failed to pay, and therefore failed to hire, a collaborator who had agreed to help. (...after 18 months of mutual silence, we came back to discuss the problems on Discord DMs)

I quickly decided, or realized, that I had to produce alone, because by then my money was basically up. I took my deceased grandpa's old pickup from my parents, readied up my emergency housing plan - a sailboat, and moved my home-lab to my parents' place of business in Michigan.

Gale

I had a couple weeks on the Chesapeake bay, examining how to handle the quirks of seaborne domesticity. Whereas 2023 had been full of cyber exploration, 2024 had been a harsh and deeply physical experience.

By that winter, I would commute most nights back to the marina in Deale, MD. The drive was around an hour and by the time I parked, the car was much warmer than the surroundings and the radio lulled me to sleep. In the early hours of the morning, the cold would rouse me, long enough to charge down the frigid dock into the hold of the boat, where I turned on the electric heater, burrowed in blankets, and on a couple occasions had to scream myself to sleep; shivers did no good.

2025

Cadence

As the winter thawed, I came to my senses. I had been making poor spending decisions, and my money was up.

I had been depending on chemical consumption, and as nomadic as I was, a couple collisions raised the price of my car and insurance beyond reach.

Even with monthly help from my parents, Most months ended with no budge in my $10k in credit card debt, and I could only access $10 - $100.

Renewed aggression between my parents and I caused me to re-think keeping my machines at their place. In March, I plugged in at a friend's home and carried on.

Rebuild

I rigged up my pickup truck as a camper, and began exploring more places from where I could log on. From NYC to Baltimore, I checked in on hackerspaces. I spent 4 days in Brooklyn, and spent $0 - though on the final day I met a friend and purchased a $4 coffee before heading home.

At NYC Resistor, I heard people speaking of HOPE. At Open Gov Hub, I heard of the Open Source Summit; I applied and acquired a scholarship pass.

I reached Brooklyn for HOPE and Denver for the Summit; In Denver I connected to leaders in CHAOSS. I headed home, and after long weeks on the road, crashed a marina birthday party; I soon had a message from management, who had cameras recording as I hopped the fence around the swimming pool. They asked me to ship off, in ten days.

I spent seven of those days at Aikido Summer Camp. I spent eleven days that month choosing a course North, to the Baltimore Harbor; I chose a berth in Pasadena, and had no more energy for sailing that rickety scrap lumber another inch. I still need to repair all the broken boards, and find sails in good shape.

Dim

During this period, I had been camping most nights in my pickup in DC; the national guard began deploying around the city, and I came to learn the boundaries of their engagement. I began to learn to beatbox at 7DrumCity's Monday open mics. At Baltimore Node, I began to examine synthesizer circuitboards.

One of my friends is going through housing problems, and I began thinking of how to help. After months of hardly speaking, I expressed many of these challenges to my mom. In prior years, they had repeatedly used nonconsensual legal and medical approaches, to address my unique issues.

By now, they began to see the purpose behind the process, and realized that their enormous resources enabled them to help. They chose a camper, I clambered in. I ended 2025 in a sequence of bus/train/pickup/camper runs, to get the pickup parked securely at the marina, where I can cancel the insurance for a few months and do repairs.

2026

Sobering

For the first moment in 18 months, I can be sure of my housing in a real sense. I can begin to make plans, looking ahead further than the end of the month.

I can spend all day plugged in, on solar, cooking and pushing ahead on my cyber aims as much as need be. And after so long, the need is really there.

I can finally begin considering how to help in the broad range of emergencies all around, rather than fearing my presence is a burden that needs to be carried by my peers.

Being able to check in more-than-sporadically, I can hold up my end of some crucial online dialogues. On Thursday this week, I held up my promise to lead a small lesson on Nushell at Iffy Books in Philadelphia. I'm re-learning the feeling of sharing among peers, rather than chasing endless leads in isolation.

More so, a recent relationship has helped me re-learn some of the empathy that has so long been obscured behind layers of sharpened aggression. The odd combination of martial arts and nomadism has made me a challenge to approach, or address; many egos end up bruised when they bounce off of me.

Eyes Open

So, how to embrace the year ahead? I am eager to focus on problems larger than mine alone.

I'd like to engage in more public communication, and hone in on how these many unique experiences can be aimed at raising the conditions of my neighbors.

On the coding side, I think that open-source is pushing into a cadence that is fully inspiring. I am finally pleased with my local machine, so I'll get back into deployments and focus specifically on approachable documentation.

I explained my production goals already. To complement my normal essays, I'll be learning typst and sharing my process more graphically.

Reaching People

I'd like to engage the many hackerspace connections towards producing similar purposeful resources on a plural scale. Perhaps this means building modular homes; acquiring open land in cities, doing the challenging legal research around zoning and building codes.

I'd like to produce music if possible, because my peers at the weekly open mic have seen me through all the ecstasies and horrors. Music is real magic, in a sense that you can share deeper meaning than language alone. The exercise of an open mic is deeply bio-mechanical, in addition to social.

These are practices that need to be amplified in the year ahead. How are you going to engage? Speak up.

"Yeah I saw that cccongress was spicy this year"
-- Waffles, on Signal.

I'll add more as I consume more.

Cory Doctorow, "A post-American, enshittification-resistant internet"

Martha Root, "The Heartbreak Machine: Nazis in the Echo Chamber" (english dubbing optional)

Another day, more progress on an assignment no one asked for.

So, another day in on preparing fiscal records. This round, I'm recording from my camper, and chose a vertical display to help anyone using their phone.

Signal is bad here, so my 1.9GB recording is really plugging up the 5g connection. I'll see when I can upload, and sorry for the delay.

Upload finished on highway.... hands free?

doing as much as I can.

gram:do is a new exercise in recording my daily progress. I'd like to make a dedicated rendering layer to place these on a calendar. Perhaps! Anything is possible if you ignore how much energy is required.

I've been focusing on keeping calm, as I acclimate to changing domestic scenario; going from pickup-nomadism (18 months) to proper camper-home nomadism (2 weeks). I do experience panic attacks, especially when becoming sleepy, which make sense in a pickup; sleep implies the approach of each day's freezing dark hours. Oddly, I also feel an uneasy sense of guilt from being able to sleep inside, warm and cozy, when so many of the surrounding neighbors are unable to secure a home.

I suppose the issue is that I spent the last 18 months, and in a larger sense the last 6 years, learning so much about nomadism and proper homelessness - including crisis management infrastructure designed more for their capacity to suck up peoples' money than to inflate their ego or (common) senses.

All this said, there really is no equal to a proper secure home. I slept until noon for the first time in ages, a couple days ago. After that I spent a few nights nocturnal, which made sense because I was hopping cars around Maryland, to manage registration and insurance concerns. I had some late-night bicycle and bus rides to follow some damp rainy nap days.

Today, I'm back to early-hours, in essence because I "phased around" by lagging through a sleep cycle. This also seems good; I like the quiet hours in the hackerspace when I can click record with no background machinery running.

This week, I'll need to spend those early morning hours preparing to speak at Iffy Books in Philadelphia on Thursday.

I do indeed hope this is all coming through in the daily progress log, and I'll be upgrading this to be more explorable, soon as possible.

Morning Recording

A couple days ago I had been able to record coding session, including my screen and accompanying audio. This morning, I spent a similar duration to record more progress on gram:fiscal.

Once I neared the end, I looked across to see that my audio recordery had been keyed to a "monitor" source rather than the USB mic. The audio dial was immobile, meaning no signal appears in the recording. I finished up, and loaded the two screen captures into kdenlive. Oddly, the video sources had the proper dimensions (I'd been recording a vertical screen) although the signal had also been blank; a dark screen.

There is one more option for producing the session recording; I had asciinema running to capture the console session directly.

Embedding an asciinema player in this domain is a little too much for my purposes, so I'll come back and drop that here if I find some spare hours. For now, there is too much to do so I'll simply run through a summary of the changes.

gram:fiscal changes

In my original session, I had produced a cache full of separated reports, by month. As I looked back through these this morning, I recognized that each page had a header, and possible tailing lines. I made up some line-based parsing logic to shed this baggage.

I looked ahead some, and found that the paging scheme differed from my expectations. Page numbers are described as, e.g. PAGE: 1(1), wherein the pages are scanning in both rows and columns, like vertical and horizontal-scrolling a spreadsheet, with the first row and the column header pinned (frozen) on screen.

This is a good realization, and a consequence of small page sizes in legacy ASCII reporting programs. Text-based tabular reporting is common across industry largely because these reports underlie processes so crucial, they were modernized... before the modern era.

Hard to imagine that governments were once the leading edge of procurement. Once they upgraded themselves into the mainframe era, no one realized how challenging an escape had become.

I'll spend one more morning on this, and then you'll be able to grab .csv or .xlsx directly from the cache, or run the nu code on your computer to reproduce the process locally, learning as you go.

For now, you can find the intermediate .noheader files in the cache (.tar.gz or .zip).

Employment on Horizon.

As much as I have done to learn the boundaries and rules of nomadism, I do feel many days as though I am simply running from place to place, unable to lend anyone use of my skills or experience, because I am simply too preoccupied with the demands of keeping up.

Recently, I've been subscribing to employment postings that are aligned with my background, so I am considering once again how to apply to the corporate sphere. In case I'm able to secure something soon, I'll be crunging numbers to see about refilling my 401(k), paying off my credit card, and perhaps paying back the camper that I begrudgingly (as in all aspects of our relationship) am assigned to by my mom and dad. Let's keep from dwelling on this too much.

Resume, in progress.

The new roles mean I need to become more serious about the application process, and I'm going to re-build my resume as needed. I have some ideas that can help make this unique and exceptional; in the past I've coded my resume by hand as a web page, including the option to render as a PDF.

On this occasion, I'm going to take that approach again, and as I re-phrase many sections to more align to my career goals, I'll seek to make the resume easier to compose and re-arrange on the fly. I'm going to make a codebase, using the new elixir nex library, that is able to compose a resume on-demand from pre-made pieces, or the basic "claims" I make regarding my career experiences.

More secure coding isolation.

Because I, like anyone else, am new to the nex package - or, more precisely, because the package is new to us, I'd like to minimize the risk of exposure to supply-chain attacks. These insiduous security holes come around when someone embeds a problem inside a crucial code package, thereby reaching coders on their local machines.

Because of several insecure practices I'm cleaning up on my local machine, I'm pausing the addition of any new programs until I clean up. Rather than run new code directly, I am using VM isolation for programs that I'm unsure of.

Some people are already seeing me explain that, sure - I can join you on Zoom, although I remain unable to patch my webcam through to the VM. Of course, if Zoom's closed-source app is not scary enough, a quick glance through their terms and conditions makes me quickly recommend Jitsi in any of those scenarios.

I'm rebuilding [gram:pool] as much as need be, to begin doing much of my local coding inside an isolated minimal VM. I'm already pleased with how easy the networking has been, and for web-apps this is a clear and sensible direction for sampling complex libraries, including niche and hypereffective graph databases, and keeping my base machine as secure as possible in the process.

Thinking ahead, these changes to pool are likely going to cause ripples, when I begin publishing code packages again. Any process I make up for building or testing a package inside a VM is going to be far simpler to automate on a dedicated build machine, because my dependency on the nix flake is going to include each necessary build recipe, regardless of any decisions for the build pipeline.

Sure sounds like a bunch is cooking here... all you can do is all you can do.

gram:fiscal is an example of how NuShell "excels" in mundane minutiae.

In days ahead, shall add code to expose records in more common and accessible forms.

For podcasts, here are the phases I remember:

• bring speakers into a shared, recorded dialogue.
• arrange and clip recordings to size, drop any bloopers.
• record the sign-on and sign-off segments.
• (no ads to be concerned for here).
• overlay recognizable leading and trailing music clips.
• publish to RSS syndication.

Keeping these in mind, here's a process I'd recommend:

• (you may already have a good process); Hook up a Mumble room, and record per-track so each source is clear.
• Bring recordings into Audacity and mix as needed.
• Ardour is able to do many special effects for a higher learning curve.
• Need any video for a change? You can also use OSS. PiTiVi, KdenLive
• You'll be sharing many audio files! I'm looking to hook up RustFS or MinIO to as independent and scalable online storage.
• Each producer can use RClone or SyncThing to push and pull copies of the media, much like DropBox.

You can adopt these pieces one by one, beginning with Audacity perhaps. I'd like to help by running the Mumble relay, and setting up file sharing beyond the (assumed) normal Google Drive. As a bonus, during my link-grab I came across a business that Audacity recommends - Audio.com seems like they can handle publishing and syndication.

Hello, from operand.online

I publish a collection of Nushell commands that I use daily, at gram:nue - here's how I reached where I am now.

In October 2023, coders at HacDC had persuaded me to learn NixOS, and a former colleague persuaded me to check on Elixir. I began to build in these languages, because I'd been unemployed since February when the House of Reps said, "no need for experimental prototypes, goodbye."

As I began to pick up the pace with these two languages in January 2024, I realized that I'd fallen behind on my learning commitment. I had aimed to pick up Nushell in 2023 also. I had been through innumerable shells by now, so I grit my teeth to dig in, expecting all the pain of migration-and-abandonment that had come from fish and xiki.

There was no "aha" moment. There were many. Too many. Each day seemed like, "Why would I build an app for this when I can do the query I need in my shell?" My full career path as a web-app coder collapsed into "do I really need more than the command-line and a capable package manager?"

So, in December I finally broke up my build codebase that had been running since 2016 and documents my progression through each shell. I expanded these configs into dedicated code for NuShell, called nue, and NixOS, called nux.

NuShell has clicked to such a degree that I no longer had a need to learn Rust. I'm finally exploring that language for game-development and webassembly ( https://bfnightly.bracketproductions.com/ ), after accomplishing years of crucial use cases in the much more user-space landscape that Nu encompasses.

Meanwhile, my web app had paused progress. The Elixir web framework Phoenix had become too cumbersome to program for. I'd been long used to a hodgepodge of languages from my days on Ruby on Rails, and Phoenix seemed to be pushing me in that direction also. Why would I learn such a cumbersome web library when i need to use React at the end of the day regardless?

So, 8 days ago when the library Nex released, I decided to rebuild.

My app already focuses on the display of code, and as I rebuild I'd like to embrace the approaches of Literate Programming to encourage discussions amid the lines of code. This is an area that GitHub has abandoned, compared to their focus on the proceduralism of code review pipelines, and the recommendation modalities of AI. NuShell is one of a few codebases that I'm eager to hold up as examples, alongside the code of Ink & Switch and chosen Elixir libraries.

I'm opening a discussion on the NuShell GitHub codebase to discuss an appraisal of their source code for security purposes. I'd like to also examine the directions they aim to adopt for concerns like nu-language package management. As much as I can encourage adoption, I'm glad to do so. This language is going to echo in my brain for the remainder of my career.

Look for the code on gram:nue/flash.nu.

Year-End Lab Problems!

I'm spending much of the holiday season in a small crisis, my mobility reduced by crucial repairs for a new camper I'll be using next year. As I camp on my friends' couch, a common theme in my career, I am held back from many of my aims because my domain seems to keep dropping offline; rather than heading back to Baltimore to cycle the machine once again, I'd like to come to grips with a more reliable deploy method.

Since mid-summer, the apps are running through a combination of two machines:

• pebble (a raspberry pi), running:
  • NixOS
  • a Nebula beacon ("lighthouse")
  • a WAN-to-LAN Caddy reverse-proxy
• baseboard (a mini-pc), running:
  • NixOS
  • a local Caddy reverse-proxy
  • miniserve
  • MicroVM.nix, managed by gram:pool
    • gram:op, through:
      • gram:pool/drop/op.nix
      • gram:pool/gram/elixir.nix

baseboard runs a couple other open-source programs, including immich as an image library, and traccar as a GPS logger. These are amazing programs for your lab, and help you upgrade your phone to "basically normal" with no dependency on Apple or Google.

These programs are possibly also the reasons that this computer is going offline, because each one is public and may include security errors or imperceptible backdoors. I am so incredibly bad at checking log files, at least until I hook up Grafana. They should probably be running hidden from the global internet, instead of my all-in approach of exposing each app under public subdomains.

Of course, I'm focused today on bringing the main app online again. I'm going to assume all of my machines are compromised, for a fun exercise.

Upgrading "Phase One".

One of the real missions of Operand is to reduce our dependency on so-called "cloud" resources.

For today's changes, I have two additional Framework Mainboard computers, ready to go.

One of them has an SSD onboard already, and this used to be a backup lab machine. I'll begin by backing up anything on that disc so we can re-image the OS and record the process from the beginning.

Normally, for a clean install of NixOS I'd begin by flashing an install disc - a "live image", onto a microSD card. I keep a case of around 30 spare microSDs, and nearly all of them are full of some install disc or other. The labeling is becoming a real problem.

To simplify this "phase one" process, I'd like to skip the SD cards and head directly to the m.2 NVMe SSD that I'll be booting the new computer from.

According to the NixOS "manual installation" guide I should be able to do this by erasing the disc, formatting it properly for a UEFI boot sequence, and then binding the disc to /mnt.

I copied the procedures described under "Partitioning > UEFI (GPT)", "Formatting", and "Installing" in the manual.

I then reorganize the partitions so their numbers are sequential. I add a couple additional partitions, nix and home, as an early basis for impermanence.

Because my shell of choice is Nushell, some of the commands have been broken into segments, passing the desired disc label into the main function to make the procedure more generic. I begin by sourcing three helper modules from gram:nue

#!/usr/bin/env nu
source ~/.nue/nix.nu
source ~/.nue/disc.nu
source ~/.nue/grammar.nu

let mem = '32GB'
let swap = [ ('-' + $mem) '100%' ]

let boot = [ '1MB' '512MB' ]
let nix = [ ($boot | last) '128GB' ]
let root = [ ($nix | last) '256GB' ]
let home = [ ($root | last) ($swap | first) ]

def part [disc: string, part: string = ''] { ($disc | into string) + $part }

def main [disc?: string, --recycle (-r) ] { timeit {
  unbind
  let disc = $disc | assure { "/dev/" + (disc choose) }
  nsh parted sudo parted $disc -- mklabel gpt

  nsh parted sudo parted $disc -- mkpart ESP fat32 ...($boot)
  nsh parted sudo parted $disc -- set 1 esp on
  sudo mkfs.fat -F 32 -n BOOT (part $disc 1)

  nsh parted sudo parted $disc -- mkpart nix ext4 ...($nix)
  sudo mkfs.ext4 -L nix (part $disc 2)

  nsh parted sudo parted $disc -- mkpart root ext4 ...($root)
  sudo mkfs.ext4 -L nixos (part $disc 3)

  nsh parted sudo parted $disc -- mkpart home ext4 ...($home)
  sudo mkfs.ext4 -L home (part $disc 4)

  nsh parted sudo parted $disc -- mkpart swap linux-swap ...($swap)
  sudo mkswap -L swap (part $disc 5)

  nsh parted sudo parted $disc -- p

  # mount discs!
  sudo mount (part $disc 3) /mnt
  sudo mkdir /mnt/boot; sudo mount -o umask=077 (part $disc 1) /mnt/boot
  sudo mkdir /mnt/nix;  sudo mount (part $disc 2) /mnt/nix
  sudo mkdir /mnt/home; sudo mount (part $disc 4) /mnt/home

  disc ls | where source =~ $disc | print
  tree -afFix /mnt
  "Copying in codebases." | print
  clone all
  unbind
  me
} }

def unbind [] {
  try { sudo umount /mnt/boot }
  try { sudo umount /mnt/nix }
  try { sudo umount /mnt/home }
  try { sudo umount /mnt }
}

The final lines run parted and then disc ls, as quick checks. We can run nu flash.nu /dev/sdb directly, or a simple nu flash.nu displays a choice of plugged-in discs.

Near the end of the command, we see the consequences:

➜ chmod +x flash.nu
➜ ./flash.nu
# ... subcommand logs

(parted)> sudo parted /dev/sdb -- p
Model: WDC WDS5 00G2B0C-00PXH0 (scsi)
Disk /dev/sdb: 500GB
Sector size (logical/physical): 512B/8192B
Partition Table: gpt
Disk Flags:

Number  Start   End    Size    File system     Name  Flags
 1      1051kB  512MB  511MB   fat32           ESP   boot, esp
 2      512MB   128GB  127GB   ext4            nix
 3      128GB   256GB  128GB   ext4            root
 4      256GB   468GB  212GB   ext4            home
 5      468GB   500GB  32.0GB  linux-swap(v1)  swap  swap

╭───┬───────────┬───────────┬────────┬──────╮
│ # │   bind    │  source   │ scheme │ name │
├───┼───────────┼───────────┼────────┼──────┤
│ 0 │ /mnt      │ /dev/sdb3 │ ext4   │ mnt  │
│ 1 │ /mnt/boot │ /dev/sdb1 │ vfat   │ boot │
│ 2 │ /mnt/nix  │ /dev/sdb2 │ ext4   │ nix  │
│ 3 │ /mnt/home │ /dev/sdb4 │ ext4   │ home │
╰───┴───────────┴───────────┴────────┴──────╯
/mnt/
/mnt/boot/
/mnt/home/
/mnt/lost+found/  [error opening dir]
/mnt/nix/

5 directories, 0 files

Add Operand's Code.

Day by day, I add code to a few programs (called grams in our lingo), used to make lab-management procedures much easier to handle.

The core of these programs, for those new here, lie in gram:nux (for NixOS code) and gram:nue (for Nushell code).

There is also gram:mech, which is probably crucial somehow, although less production-ready than the others. Used to be, all three of these were included in a single codebase, called gram:build - the pieces were unique enough to break them up.

def "clone home" [--user (-u): string = nixos] {
  let home = $"/mnt/home/($user)"
  if not ($home | path exists) { sudo mkdir $home }
}

def "clone base" [base: string, --user (-u): string = nixos] {
  let loc = $"/mnt/home/($user)/($base)"
  if ($loc | path exists) { print $"Oh no! ($loc) is already loaded."; return; }
  nsh gitoxide sudo gix clone $"~/($base)" $"/mnt/home/($user)/($base)"
}

def "clone loc" [base: path, --user (-u): string = nixos] {
  let loc = [ /mnt/home/ $user $base ] | path join
  nsh rsync sudo rsync -av ~/share (clone home -u $user)
}

def "clone all" [--user (-u): string = nixos] {
  clone home
  clone base .nue --user $user
  clone base .nux --user $user
  clone base .mech --user $user
  clone base page --user $user
  clone base diagram --user $user
  nsh rsync sudo rsync -av ~/share $"/mnt/home/($user)/"
}

Nix Machine Config?

Nix has a command to generate config files, and I'm skipping that recommended config because after two years, I know enough to rebuild the good pieces and skip the unnecessary.

The challenging piece here is the file commonly called hardware-configuration.nix; this specifies a number of boot options, alongside the disc labels and paths they should bind to during boot.

Lucky us, we're already working with those. Rather than the fickle /dev/sda and so on, we'll grab the device UUIDs, which should be reliable even when the disc is moved to a different machine.

def "label" [disc: string, part: any] {
  (ls /dev/disk/by-uuid).name | where {|id| ($id | path expand) == (part $disc $part) } | first
}

➜ source ~/disc/flash.nu; label /dev/sda 2
/dev/disk/by-uuid/bf6fd2e3-b0f2-44fe-99c5-9237ad751a48

I can use this helper to build up a new nix config, depending on the architecture of the processor and assuming our 5-partition scheme.

def "nix bind" [disc: string, part: int, bind: string, --form (-f): string = ext4] {
  $"fileSystems.''($bind)'' = { device = ''(label $disc $part
  )''; fsType = ''($form)''; };" | str replace -a "''" '"'
}

def "nix swap" [disc: string, part: int] {
  $"swapDevices = [
    { device = ''(label $disc $part)''; options = [ ''discard=once'' ]; }
  ];" | str replace -a "''" '"'
}

def "nix machine" [disc: string, arch: string, kernel: string] {
  ([ (nix preamble)
    (nix arch $arch $kernel)
    (nix bind $disc 1 "/boot" -f vfat)
    (nix bind $disc 2 "/nix")
    (nix bind $disc 3 "/")
    (nix bind $disc 4 "/home")
    (nix swap $disc 5)
  ] | flatten | each { "  " + $in } | str join "\n" | str trim) + "\n}\n"
}

def "nix preamble" [] {
'' + `{ config, lib, modulesPath, ... }:
{
  imports = [
    (modulesPath + "/installer/scan/not-detected.nix")
  ];

  boot.loader = { systemd-boot.enable = true; efi.canTouchEfiVariables = true; };
  boot.initrd.availableKernelModules = [ "xhci_pci" "thunderbolt" "nvme" "usb_storage" "usbhid" "sd_mod" ];
  boot.initrd.kernelModules = [ ];
  boot.extraModulePackages = [ ];
`  
}

def "nix arch" [arch: string, kernel: string] {
  [ $"nixpkgs.hostPlatform = lib.mkDefault \"($arch)-($kernel)\";" ] ++ (
  if ($arch == 'x86_64') { [
    "hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;"
    "boot.kernelModules = [ ''kvm-intel'' ];"
  ] } else {
    "boot.kernelModules = [];" })
}

This means a simple one-liner prepares the necessary machine.nix:

➜ source ~/disc/flash.nu; nix machine /dev/sda x86_64 linux

{ config, lib, modulesPath, ... }:
{
  imports = [
    (modulesPath + "/installer/scan/not-detected.nix")
  ];

  boot.loader = { systemd-boot.enable = true; efi.canTouchEfiVariables = true; };
  boot.initrd.availableKernelModules = [ "xhci_pci" "thunderbolt" "nvme" "usb_storage" "usbhid" "sd_mod" ];
  boot.initrd.kernelModules = [ ];
  boot.extraModulePackages = [ ];

  nixpkgs.hostPlatform = lib.mkDefault "x86_64-linux";
  hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;
  boot.kernelModules = [ ''kvm-intel'' ];
  fileSystems."/boot" = { device = "/dev/disk/by-uuid/D7F2-26FE"; fsType = "vfat"; };
  fileSystems."/nix" = { device = "/dev/disk/by-uuid/bf6fd2e3-b0f2-44fe-99c5-9237ad751a48"; fsType = "ext4"; };
  fileSystems."/" = { device = "/dev/disk/by-uuid/847b4009-0ae6-4219-9799-635092ea6879"; fsType = "ext4"; };
  fileSystems."/home" = { device = "/dev/disk/by-uuid/f425a3b1-82e6-4c3b-89f0-cbd85e952162"; fsType = "ext4"; };
  swapDevices = [
    { device = "/dev/disk/by-uuid/8c6c0ee0-9226-43e2-92fb-5adbef5225c9"; options = [ "discard=once" ]; }
  ];
}

Because of the odd permission scheme, we need to make a new shell to record this file inside our disc, overwriting the prior config.

sudo nu -c $"(nix machine ($disc) ($arch) ($kernel) | to nuon) | save -f '(clone home -u $user)/.nux/cell/($machine)/machine.nix'"

Now, we can add the kicker to the end of our main function;

  sudo nixos-install --flake $"(clone home -u $user)/.nux#($machine)"

Build, Error, and Rebuild.

From here on, I began running the code again and again. I added a rough idea of user accounts, and made sure the code to clone our codebases honors the chosen user.

I spent some hours seeing if I could cross-compile, because I have deployed nux configs on both x86_64 (intel) and aarch64 (arm) processors before. The problem seems deep, so I'm going to pull back. I can choose a pre-made config for arm or x86 on a case-by-case basis, the configs are similar enough.

There seems to be an incredible delay because gram:pool needs to be copied to the nix cache; this seems to depend on an 18.5 GB source directory, so the disc seems to take an endless span to build.

I displaced /pool/disc on my local computer, so nix should be able to proceed quicker - and yep!

Choose arch:    x86_64
Choose kernel:  linux
Choose machine: baseboard
warning: Git tree '/mnt/root/.nux' is dirty
warning: Git tree '/mnt/root/.nux' is dirty
copying channel...
building the flake in git+file:///mnt/root/.nux...
warning: Git tree '/mnt/root/.nux' is dirty
evaluation warning: You have set specialArgs.pkgs, which means that options like nixpkgs.config
                    and nixpkgs.overlays will be ignored. If you wish to reuse an already created
                    pkgs, which you know is configured correctly for this NixOS configuration,
                    please import the `nixosModules.readOnlyPkgs` module from the nixpkgs flake or
                    `(modulesPath + "/misc/nixpkgs/read-only.nix"), and set `{ nixpkgs.pkgs = <your pkgs>; }`.
                    This properly disables the ignored options to prevent future surprises.
evaluation warning: Using 'addressConfig' is deprecated! Move all attributes inside one level up and remove it.
evaluation warning: Using 'addressConfig' is deprecated! Move all attributes inside one level up and remove it.
evaluation warning: Using 'ipv6PrefixConfig' is deprecated! Move all attributes inside one level up and remove it.
installing the boot loader...
setting up /etc...
Created "/boot/EFI".
Created "/boot/EFI/systemd".
Created "/boot/EFI/BOOT".
Created "/boot/loader".
Created "/boot/loader/keys".
Created "/boot/loader/entries".
Created "/boot/EFI/Linux".
Copied "/nix/store/kiplbb6yv7rmjf21hf9ky01b9kmgmnqn-systemd-257.10/lib/systemd/boot/efi/systemd-bootx64.efi" to "/boot/EFI/systemd/systemd-bootx64.efi".
Copied "/nix/store/kiplbb6yv7rmjf21hf9ky01b9kmgmnqn-systemd-257.10/lib/systemd/boot/efi/systemd-bootx64.efi" to "/boot/EFI/BOOT/BOOTX64.EFI".
Random seed file /boot/loader/random-seed successfully written (32 bytes).
Created EFI boot entry "Linux Boot Manager".
setting up /etc...
setting up /etc...
setting root password...
New password:
Retype new password:
passwd: password updated successfully
installation finished!

Now to reboot and see...

Disc Label Problems.

All my nice code for binding disc labels to nix code seems to be... meh.

I guess I should say - and perhaps already did - that disc labels can be super fickle.

I spent around six build cycles trying to map the disc based on ID / UUID / label, by the disc and by the partition, and during the boot cycle none of these picked up. I have no idea how these labels are applied during phase one of nixos boot.

The piece I did know of is that my specific computer has an internal disc bay, and that shows up as /dev/nvme0n1. This had been my final chance at a boot sequence.

I re-coded the nix machine command to take an aim, and placed each partition according to the aim of the disc. This means that the boot is going to be much less generic than I'd hoped, and I do plan to come back to this problem, and look deeper at the phase one boot sequence.

For now, I chose nvme0n1p from the menu and imaged the disc. I ran shutdown now, opened the disc enclosure and my laptop, and exchanged the memory cards.

I pressed the power cycle, and held my breath.

The disc booted.

Epilogue.

For the remainder of the day I'm going to be in manual mode, because I need to be on the road soon as possible (as usual!). My main issues are to hook up networking, and then drop nebula certificates onto the machine so I can log in from anyplace.

From there, I'll be able to redeploy the app and share this saga with you all. Look for the code on gram:nue/flash.nu.

Years ago I'd been relaxing alongside my brother and some of his friends from high school, at our parent's home where they began their retirement in Michigan a few years ago.

Around October - December, I'd guess - we'd been outside for a fire because they're back in the woods, and seems like there hadn't been snow yet that year because someone began speaking of the lake, down the hill and through the swamp, where we had spent a few years building a boardwalk to gain access to the small pond called Quiggle Lake.

Quiggle, oddly, is an old name of some ancestors on my mom's side. Unsure how we peeled off from that group, or how my parents found the old Quiggle farm to retire on. They bought the place from the German architect who had designed the home, after his messy divorce. Sounds like he left behind the magnificent lodge that he had designed from the bare scraps of his dreams, where he had plans to raise his grandchildren, and he shuffled off to a small apartment building for his old age instead.

Plans are easier to make than to keep.

Someone began speaking of the lake, and from the chill of the air we were beginning to plan a polar plunge, where we go leap into the deep dense abyss, sense the pain and panic of the scenario, and scramble back up the ladder and the boardwalk and the hill to have a second plunge in the hot tub, near the fire.

I'd been eager, and one of my bro's pals also, so we braced up and headed there.

On the end of the dock we felt the cold air coursing by, and decided to hold hands as we ran and leap'd from the floating boards.

In the air, I held his hand and he began pulling away. For a moment his recoil pulled us closer together, I guess - and then the cold rushed in.

Cold can make you numb, though you need to embrace it for long enough if that's going to happen. Usually, cold makes you panic - there's no pain, in a physical-harm sense, though an unconditioned brain usually sees panic and pain through the same lens. You become shocked.

For us, the shock is soon rewarded by a dip and a soak in the hot tub up the hill. I've seen that pal once since, at my brother's marriage ceremony in San Gregorio California, a rare gathering we all arranged during the lonely pandemic years.

Cold can make you numb, though you need to embrace it for long enough if that's going to happen.

The sensation begins as shock, and I shared the shock I had from a polar plunge in a Michigan lake.

I'd like to share in the shock all of us are sensing this season, learning of the cold scene surrounding us, and in the early moments of recognizing the harms we can slip into.

Sorry, hours passed. There had been something to take care of.

I'd like to share some of my procedures for exploring records, because the more people seeing the depths, the more there is to discuss.

There's a shock from the exposure, and a panic begins to place a grip and a horrible hold; so keep company you can rely on and reach for a caring hand.

I used to have a scheme for easing my discomfort around people; my body dysmorphia has been really serious in years prior, and in my adolescence I was anxious around the idea of sex.

My biological parents were raised in Michigan, so I'm rather sure they have no idea sex is possible.

I was raised on the East coast near Philadelphia, so friends around school would discuss casual hookups that would make me blush, in my grandmother's place.

Being so aroused, and unable to find the language for my predicament, I learned that you can ease the quickening qualms of pubescence by focusing your mind on challenges, such as math puzzles.

Here are some number puzzles that may help hush your ol' bones.

1984 - 13 = 1971
2025 - 79 = 1946
1984 - 1946 = 38
13 + 13 + 13 = 39

Can you do simple maths in your head, especially during occasions where you are becoming aroused?

How do your physiological conditions make it challenging or easy to go numb, so as to focus on numbers such as dates and years?

Do your mental conditions keep you from seeing, or thinking, or empathizing clearly, especially when you are called upon to relate intimately and compassionately?

Maybe I'm thinking too much like my dad, who had a career in finance and did a bunch to emphasize math problems.

He is usually clueless, though occasionally he sees when the scene fails to add up. He likes to say, if you find yourself in a hole - stop digging.

Quiggle Lake is deep, and the bottom surface is murky and silty, so the rumor passed around is that indigenous people said the lake had no bottom to it.

Seems too deep for something its size, and maybe someday there could be a chance to use submersible cameras or scanners around there.

Being from Michigan, I feel like water is a calling as much as a surrounding. Sure feels ethereal when you drop something meaningful, and realize some things are impossible to undo; some burdens and losses that mark a mind by their absence, more than they had a chance to, by their presence.

As I said in the page I prepared mid-day...

Please email public@operand.online if you'd like to discuss, or ask for help, or lend help, in examining this record collection.

The immediate concern when you are flooded in shock, is how to reduce your panic by pursuing a clear course of action.

Occasionally, this becomes your chance to explore how capable you really are. Perhaps you had failed to prepare the clothes to dry off properly, so you need to see how quickly you can run to a cozy perch in the House.

Perhaps you also realize you need to increase your circulation, and blood pressure and glucose levels, because the shock has knock-on effects. I like to keep fresh produce around for these emergencies, such as oranges and peaches.

They go together, although mind the bitterness and be ready for the fuzz.

These approaches are sure to bring you back to your senses; as a cold plunge is accompanied by the anguish of panic, simple remedies are crucial, regardless of how commonly used, and are your only recourse during such unusual horrors.

Remember, hold people close; and hold your breath as you go under.

You see the wind-up, and here's the pitch.

Build Missing Pieces, in Public.

Operand Company has an ongoing marriage to open-source programming. This is a challenging dynamic to uphold, because the year is 2025 and we're all challenged beyond measure. Global telepathy landed on Earth around 45 years ago, and in 45 small years all of us slipped loose our sanity.

In the end, global communication really sucks. There's so many people to care for, so much pain to sense, that all of us go numb from the simple reckoning.

There's no turning back the dial on this one, though. The speedometer is cranked up and the brakes line snapped, so let's keep heading for the open spaces and seek a means of adding some friction to the mix.

Here's how to build some new brakes into the speeding global economy, at 299,792,458 meters per second. Buckle up.

Missing Piece # 1: Media ON-line (MON)

Music production is big business, and so are the programs used to make modern songs. You need sample packs, percussion patterns, bass lines, input controllers for MIDI. Then you get into live playback and recording, using loop pedals and sequencers. You can build a full rack of gear, for plug-and-play operation of your precisely-tuned signals.

Many people leap the queue, and purchase Logic Studio, ProTools, Ableton, or BitWig. These programs are the big incumbents, and there are others besides. The open-source choices are unable to keep pace; although more of the building blocks for these programs are ready to go than ever before.

Full programming languages and sound-rendering playgrounds are up and running today: Faust, Strudel, and VCV Rack are the primaries. Of these, more colourful combinations can be mixed.

Audio? Sounds like a good place to begin, sure. I'm especially eager to see how graphics and motion can be blended into the mix; made of a signal, channel, frame - all the same. You may also see some Friction animations used to explain coding ideas on this domain soon!

Open Source programming has a rare chance to leap a full industry ahead in the music space, based on research being done in a field of programming called Local-First; mainly based on a collaboration library called Automerge by Ink and Switch alongside a messaging layer called Iroh by number0.

Sorry, in build-mode already. Hurry up and help!

These programming approaches enable full production groups, small media businesses, and independent band members to all log onto the same program space, modifying the same media landscape with all cursors on one page.

I've spoken to band members who assembled albums by emailing home recordings to one another.

Seriously, dudes. Upgrade already!

Build in the open, or share your media broadly so more people can remix than anyone heresofar has imagined possible.

The age of open-source code needs to embrace and enable the age of open-source media.

Pass the mic around! I need that new sound. (open-mic freestyle session at The Pocket, DC)

Missing Piece # 2: 3D-grees (D3G)

Once you're done splicing Faust, Strudel and VCV Rack - hold on, hurry up!

We're gonna take on this one in parallel. To begin, here's some background on how open-source is coming along in realspace.

If you click around the documentation pages of Open Source Ecology, you'll come across designs for fully-functional housing modules, industrial-grade farm equipment, a car, a bakery oven, bioplastics extruders and welders -- seriously, go click on the documentation and be as amazed as I am.

All of this gear is designed to be rapidly-reproducible from basic supplies. These designs can be passed freely across the globe for a shipping fee of zero point zero. Once someone with a need has the designs, though -- how are they to use them?

Even basic 3d-printing has had a hurdle to hop for beginners, and many are limited in the field by the lack of knowledge of 3d-modeling programs. 3d catalogues like Thingiverse, Thangs, and company are all good for the quick fix, but complex pieces are held up from - existence? production? realization? - because so many people need to learn complex modeling programs.

Again, the industry has been siezed up in an iron-clad grip by SolidWorks, AutoDesk's Fusion360, and now the modern challenger Zoo. These and similar programs that place the opening bid at a corporate or academic license.

Such predatory pricing policies place precarious pressures precisely on pupils preparing precious public production plans. Please, people.

Already in this space? If you're dedicated to building re-usable designs, you're likely using the cumbersome combination of OpenSCAD or FreeCAD. Perhaps you've had to bend Blender, a 3d-animation program, to the requirements of solid engineering. Shapr3d promises to do all they can to lock your designs in the cloud until they're properly mined for machine-learning models. If you're using anything else that doesn't require corporate or academic sponsorship, please message me because there's a species on Earth that dearly needs to know about it.

So, the moment we've all been eagerly asking for: a mission up to the serious skills of all those misguided and misanthropic independent game production businesses (mine included?).

People know how to do 3d modeling for games, and they'll push silicon to the edge of physics and back for a chance to see the machine humming through complex scenarios.

A simple forum and all the moderation should be all it takes to get this ball rolling. And screws turning. And cylinders firing.

Solid plan!

Missing Piece # 3: Mesh INDex (MIND)

Here's a lesser-recognized issue to cap off the tables.

I've heard here and there, rumors of a "graph database", called Neo4j that is able to accomplish some miraculous indexing and domain-modeling challenges.

In this sense, "domain-modeling" means we are no longer producing signals as in missing piece #1 (MON), or shapes as in missing piece #2 (D3G). We're modeling a space to explore ideas, and the links from one idea to another. If you've had a chance to explore WikiData, this needs no explanation.

So, I had some luck running Neo4j and quickly asked if anything else is out there. I had a read-up on the curiously-named Apache Tinkerpop, which has a nice summary of the current options for graph databases in production. 26 currently, is my enumeration, and once I clicked through to the source code, I learned that one is obsolete, one fails to support the common Cypher query language, and the remaining 24 are made in Java.

This is the reason no one uses open-source, because there's a huge missing piece in the middle.

Databases are becoming simply incredible. As long as you use relational databases. I could explain all that's going on these days in ElectricSQL, Jazz, Graft, and heck - I'll throw in a bonus document-store database because we already spoke of Automerge.

All that's going on these days in ElectricSQL, Jazz, Graft, and Automerge - is sync.

Sync is here. Sync is good. Use sync.

Sync also needs to happen in graph databases.

Sync to graph databases means offline Wikipedia - only the pages you care for, or the search results you choose, or the idea you're researching plus the pages reachable in 3 - no, 4 clicks. Sync means offline mode. Offline social media. Sync means "I SAID DO NOT DISTURB!"

Sync means so much, and graph exploration means so much, because there's simply too much of this online mess to care for all of it at once. So graph the pieces you see, map the links you care to see, and finally query using a model that has a clear analogy to the way we all already see the online sphere.

Once you see the problem space clearly, you can make the connections you need. These graphing problems are the basis of Operand's diagrams in D2; these nuanced maps could be made in seconds, from real sources rather than LLM hallucinations.

Best yet? That Cypher query language I lobbed up earlier is really OpenCypher, a full spec of how graph databases should operate. A full spec that can be clicked into any programming language we choose (Rust) to put production into hyperspeed.

Since we're in Rust already, you know we're going for client-side webassembly. You can be sure we're going to do in-memory programming-language embedding, so you can graph database from your Python or your Ruby or your Elixir or your Go. Rust means all languages are good to go from day one, and the people who like clicking the keys on their mouse more than on their keyboard are on equal ground for exploring the scenes.

There's so much to explore! And so much more we can do, once we add meaning to and purpose to the scene.

I hope to speak on these ideas soon, and perhaps record some ensuing discussions. There shall be forums for sure. Please message sponsor@operand.online, because my parents are sick of paying for my 5g charges, and the builders in Baltimore are gulping up all our cheap ramen.

Peace, please people. Happy to help.

So as to keep my mind as clear as possible, here are my plans. again.

Pool

Pool is designed to be the hub of your local-web; keeping your primary relay online and secure by using MicroVMs and local networking to deploy and manage open-source web apps.

POOL:

Relay

Relay is a desktop or local-web app, designed to run sandboxed peer-to-peer communication using AtomVM, and using permissioned message channels to manage OS operations, through a local rust compile-and-plugin procedure.

RELAY:

Ages ago at HacDC, in October 2023, people sparked my curiosity for NixOS. Early on, I became inspired by a guy named astro who was building the slickest VM-management layer I’d seen.

Obligatory CCC link enclosed.

2 years passed as I learned enough Nix to make sense of the docs. I have gone without docker or containers for too damn long. No one should need to learn all the edge cases of astro’s package, and all of us should be using his approach. So, how do?

I’m rather pleased today to launch a new package, for pooling programs as NixOS VMs:

gram/pool

Launch Dialogues

Calliope, 1:05 AM

There has been so much consideration placed behind this, I'm thrilled to begin building up from here. Maybe I'll finally climb back down from theops peak soon and head back to the rolling hills of app design.

Calliope, 10:56 AM

Here is a real deployment-grade program running on pool. This dense screen is displaying, from left to right, top-to-bottom:

• A running microVM, on a local-only IP address of 10.0.0.31, running Neo4j
  • lsmem
  • ip a
  • journalctl -fu neo4j
• An Elixir/Phoenix connection to this Neo4j db
  • setup guide (neo4j password)
  • phoenix config
  • phoenix console using boltx library
• https://microvm-nix.github.io/microvm.nix
• https://hexdocs.pm/boltx/readme.html

Search for neo4j on: https://operand.online/gram/pool/flake.nix

and see more options on: https://search.nixos.org/options?channel=25.05&query=services.neo4j

There are a half-dozen other apps I'd like to add in, at a pace of 2-3 per day, before I give this a spin on my lab at the Baltimore Node hackerspace.

Calliope, 11:03 AM

Remaining issues:

• per-pod namespacing

  VMs are now named only per-app, so only one copy of an app can be running at any moment. This error comes across when accessing tap on /dev/net/tun.

• reliable networking

  Nebula should be used to ensure programs can be dropped on myriad machines in an ad-hoc manner, and IP mappings and routing remain in place.

• prepare subdomains using caddy

  caddy can proxy traffic and assign SSL certs, for easy domain-name management; with all unencrypted networking confined to a single machine.

For me, August 2025 is going to remain the most spectacularly unplanned and chaotic mess of garbled memories, where each day carried so much nuance, and so many challenges, that there has been scarce occasion to pause and breathe, to reshape the experiences into more than the layered percussions of sun, moon, sea, sail, spoke, and signal.

I hope there is a chance to re-use that opening paragraph, in a closer examination of the days of August, only I need to begin by describing changes happening across this domain.

If you happen to be reading this, or perhaps if your RSS reader is doing a refresh, before 6pm on Thurs 09-04, you may only see a partial essay.

Background: Realizing a long-held dream.

I had good reason, cause, and chance to move my app deployment, from the basement where I lease a static IP address, to my local laptop, which I've had to leave up and running all night, in a hacker-space called the Baltimore Node.

I'm sure others have likely managed before me, a production online app running from a laptop. In my case I am especially pleased to do so, as a reinforcement of the aims described in the business' incorporación proposal.

When I composed the proposal in 2024 I was inexperienced in essays, and I need to apologize to the DC employees who had to read through that rubbish; moreso because as I began this company I was also in a phase of psychedelic experimentación.

If you dig through that essay, in a sense a legally binding one, you'll see the key theme is an idea I call "sublimación".

I realize now that my founding essay was simply a poor re-hashing of an idea explained much more clearly and simply in the Local-First Essay by Ink & Switch. They open by saying:

Cloud apps like Google Docs and Trello are popular because they enable real-time collaboration with colleagues, and they make it easy for us to access our work from all of our devices. However, by centralizing data storage on servers, cloud apps also take away ownership and agency from users. If a service shuts down, the software stops functioning, and data created with that software is lost.

It has been said before in the "local-first space" that numerous people are reaching the same conclusion from different initial conditions. The realización that our building processes are flawed, doomed to someday fail, is a process that can occur in a dispersed manner, like the many [origins of infintessimal calculus], or the rich explosion of humanist philosophies during the Axial Age

However the conclusion is reached, here we are.

Each of hundreds of programmers and small businesses are choosing a small niche in the local-first space. A full index is a good place to begin for end-users who are sick of usual app-store norms, and LoFi.so has many resources to choose from, including the Local-First Discord. Need to read more? See Local-First News.

The area I chose as a primary concern is unusual for the space, which is likely why I had been such a late-comer, missing the forest for the trees.

I chose to focus on web-app deployments.

2025 Aim: Reliable Deploys

Of course, 'web-app' can be seen as an antithesis to 'local-first'. If you agree, maybe I can change your mind.

Yesterday I came across an app I'd like to build into the mix, called Shiori. The purpose is to aggregate and label bookmarks, and enable an offline-reader mode for easy mobile access. There is no cloud-based company managing the program, and the features drop it categorically into the local-first space.

Shiori remains a web-app, and is capable enough for many users to access, although the primary audience is for a single-user per deployment. To run Shiori, users are encouraged to launch a web domain themselves.

Many apps are being produced in this manner because of the rising popularity of home-labbing, perhaps known to some as self-hosting. Besides, the web has made up some really amazing norms for apps that are dynamic and accessible, and is much more pleasing to build for than most "native" OS apps.

To launch your app's domain, the normal approach is to lease a machine from a cloud company. In this case, for such a simple app, the easiest option may be PikaPods. More experienced coders are familiar - and correspondingly sick of - flexible options like Linode and DigitalOcean, which probably are happy to lend our login credentials to the nearest NSA field office at the mere whisper of enforcement.

So, until now every domain manager had two choices:

• add to Amazon AWS or Akamai's global reach, by signing on to use their machines (usually repackaged by a cloud middle-manager)

• order a business internet plan, and consent to days-on-end of random phone calls with your ISP, to order a static IP address rigged up.

I'm partial to the second option, because reaching local-first dominance has to both amplify the share of local apps and programs, and crucially, reduce our dependence on cloud data centers.

I'd like to see a report each billing cycle, describing how much water my apps drank while they were being cooled by Google's electron-warehouse plumbing.

The deplorable shape of our industry is plain to see when passing through Ashburn, VA - a close suburb for me to reach, where there is no business, no one in sight, and only a bland shopping mall for amusement.

These are human prices of our industry that need to be recognized and addressed.

March 2025: Baseline Lab

Although my company's purpose is to bring the web back to the home, a further complicación had been... my lack of a home.

I am nomadic, carrying my home around in a pickup truck or a sailboat each day, and so I'd like to accomplish as many of my aims as possible while being as locación-independent as possible.

For the static IP address, I called up my pals in Upper Marlboro, MD; there is a home there full of the most generous people I know. I arranged for a business internet line to their home, and placed a couple machines in their basement.

I'd been commuting from place to place, and would occasionally find a chance to go by and check on the machines, manage upgrades, plug and unplug cords. The biggest flub had been encrypting the boot drive; each reboot required hands on a physical keybard. Nonetheless, the process remained in place through much of August. Six months on a static IP address!

Then... let's discuss how August went.

(beginning) August 2025: Sailing Fiasco

The "friend's basement" playbook is, eh, more or less manageable when you live in close proximity, are capable of a deep bond of co-reliance, and are equal shareholders in the success of the program.

I'm unsure how I scored on any one of those marks, though the deployment held up until a small crisis landed on Aug 1, requiring me to immediately set sail.

A sailboat is an ideal place to run cyber exercises. Because there is no escape from the physical isolación, the only connección you are likely to find to other humans has to be relayed to you through radio signals.

I dove deep into the Self-Hosted Podcast and Linux Unplugged, and called into many cancer research calls, where the group was far more eager (or enabled) for me to put the "comp" into "computational biology" than they were to put it into "compensation".

Of course, I had experiments to run. I launched Mumble. I launched Traccar. I launched n8n, and shoe-horned comment fields into the essay pages.

And I broke the lab. Again. And again.

To the dear residents of Larry Cat House,

I am so so sorry, sincerely and immensely so, for the endless calls on Signal where I explained complex passcodes and cable-plugging procedures, and the "quick sanity checks" where none was found.

I had to balance downtime for a core-business client app, my need for experimentación as a coping mechanism, for lonely breezeless days, and the superb annoyance I caused my pals back on land each day, immediately after promising it (probably?) wouldn't happen again.

I hung on like this until I got back to land, and spent one day fixing up the lab to get the blog running again before heading to HOPE. I promised myself I would do no experiments while I was in NYC, and besides I had no more energy to do so.

I was getting enough of a cyber-social buzz from the conference, and NYC is the deepest end of the social spectrum to drown in, after two weeks on a rolling bouncing bay.

After NYC, I headed back to the lab. I had ideas to manage, more grand plans. I had decided to separate the apps and the experiments, leave the production app running as I brought the bulk of the lab to Baltimore Node, where I could exhaust days on end running necessary experiments and building at high speed.

With all but the core production machine "baseboard" loaded into my truck, I locked the door to my friend's house behind me and began to pull out of their neighborhood.

Then I remembered. I should check if the app is online!

Not only no app, but no signal. No SSH.

I spun around, rang the doorbell, met the new roommate, and pulled the final cord out of Baseline Lab.

(end) August 2025: (re)Building Blocks

However much sleep I had lost in the preceding days, I was soon to lose more. My usually inattentive client quickly messaged me, saying "the app is down. Can we host it somewhere else?" and of course I said "yes, please".

I recommended fly.io because heck, I'm finally beginning to recognize my mission as a smidge on the idealistic side. If at all possible I can keep my ideals from holding up my pals' business, I suppose I should.

I burned a couple days building a proper Elixir/Phoenix Dockerfile, double-checking port and IP bindings between my config/*.exs files, and I finally had a reliable deployment that no longer breaks the memory limits.

On my breaks, I honed my process for launching NixOS on a Raspberry Pi, and soon headed back to Larry Cat House to plug one in; then a second.

The first pi I launched is called pebble, and for around a week this had been running the blog. On a couple occasions, I checked in, and thought I saw that the pi had crashed; then, a few hours or the next day, the app would be online again.

Clearly, the app is seeing more than zero traffic, and the pi is unable to keep up. No problem; the second pi I plugged in enabled me to experiment with Nebula. Nebula, in essence, enables me to spread the lab out to any number of geographically dispersed areas.

I placed some Nebula certificates on the two lab Pi's, assigned certs for my laptop (chesapeake), and with only a few days of config & network-address munging behind me, I can finally keep a reliable connection up between my chesapeake, in Baltimore, and pebble, in Upper Marlboro.

September 2025: Dispersed

As much as I like the reliable connection between here and there, the glory lies in the opposite direction: I can keep up a reliable connection from there to here.

Remember, there, where pebble is running, is the business line static IP address. pebble is only a low-grade Raspberry Pi 4B with 2GB RAM, purchased before I knew what to look for in a single-board computer. pebble kept choking and lagging when asked to compile markdown for a blogging engine.

When pebble can reach me here, on chesapeake, a full-blown x86 coding machine, the game fully changes. I kept the blog running at full capacity, by disabling my idle timer through the night, leaving the laptop plugged in to charge, on a residential wifi connection, reaching far higher speeds than the pi could manage.

I kept the blog running even as I ran Blender, and downloaded a bunch of YouTube videos explaining how to use Blender. I kept the blog running even as I compiled Blender from scratch, because that's how things go on NixOS, and there was no single hiccup in the response or lag from the app.

Finally, I logged on this morning and began playing around with the essay, and realized that as I saved my progress, the rendered page displayed the changes - on the public ://operand.online domain.

In essence, I signed up my pals for a static IP address, and made sure my domain's DNS records all point to that address. Then, I rigged up Nebula and Caddy to reference an address on a Nebula virtual-LAN; the magical, ephemeral, dispersed layer that replaces all networking headaches with certificate-management headaches.

As long as Nebula and Caddy agree on an IP address for the app machine, and Caddy and the app-machine agree on a port number for the app, and Caddy and the app agree on a domain name, then the app can be run on any machine, any place, regardless of network setup.

Of course, this experimentation process has required me to make serious changes to the business plan, so that much of what was described under BASE is now marked as 'broken' in red, and moved to NODE, where I can be more hands-on with my experiments, for much less risk.

A Moment, to Breathe

Some may say I am in a precarious posición, with my business. Why be nomadic, why go sailing, why be so un-employ-ed -able? There are few role models to choose from, when breaking so many norms, so I am lucky to rely on essays that stretch the seams on this world.

In her essays Ismatu examines the social scenarios of her tribe, and the consequences of being raised a child of two nacións.

I feel an immense bond with this composer, who I hope I shall be lucky enough to speak to, and collaborate alongside someday, by my own happenstance of being born in London, raised in Tokio, by midwestern parents.

Global children like us are fully incapable of considering the nonsense of a flat-earth hypotheses, because we have seen the curvature of the earth from the window seats of numerous long cross-oceanic flights.

Global children like us are less prone to ensnarement by a corporate mission statement,i spun around, rang the doorbell, met the new roommate, and pulled the final cord out of baseline lab. when we recognize that the mission ends where the state's boundary lies, less prone to being hooked by a viral ad campaign when we can examine a global virus campaigning through places once called home.

I'm sure that in the middle of the largest rapidly globalizing crisis our species has yet encountered, all one can hope to do is find an area where their skills can shine, press them into full gear, and share the consequences publicly as loud and openly as possible.

In my case, this consequence seems to be the simultaneous dissolución of the core mechanic underlying the business models of Amazon AWS, Google Cloud, and Microsoft Azure; the mechanism laid in place by ISP providers such as Comcast, AT&T, and Verizon, many years ago when the first phone lines began being repurposed for internet purposes.

The static IP has been the bane of my career, and in the end this windmill has been blown away by the deployment of a single Raspberry Pi, running a background Nebula process.

Going ahead: a Reproducible Base

Again, nearly nobody I know has a static IP address, and more and more people I know have apps they'd like to launch, and spare old machines lying around home with no purpose, and gradually depreciating innards. This is the problem of sublimación; the economic resource of silicon doomed to disuse, by lack of access to the demanded use cases.

By chance, Baseline Lab is my second failed static-IP experiment; the first one being in my parents' place of business in Michigan. Seeing as I have two static IPs to make use of, a business model comes to mind.

Soon, you'll be able to log in to ://operand.online, and for a choose-your-donación price, or pay-by-bandwidth for larger apps, you can send along your domain name to us, and I'll issue you a Nebula certificate. You can choose a static IP address from our list of nodes, to use as a relay for your web app. Any one should do, so choose based on geography.

You can assign your DNS records to our static IP, and our Caddy reverse proxy can begin handling your app's call-and-response through our Nebula mesh.

For memberships needing more nodes on a single mesh, perhaps you'd be open to on-demand cert allocación & revocación from a secure app, on a dedicated nebula mesh.

Of course, no one can build on such a core open-source library such as Nebula, unless you also run open-source. No problems here, this has been the case for Operand since day one.

I can see many docs pages ahead, for gradually-sharpened essay skills to go to use.

I'm beginning to imagine the nuances of a peer-to-peer product, similar to LiveBook and Observable, based on Tauri, and embracing the ideals of Local First programming.

Why bother?

To approach Tauri, the desktop-app layer, I am upskilling in Rust - and gearing up a dependable webassembly compiler pipeline. Tauri 2.0 adds mobile apps to the mix, including iOS and Android.

My primary lang, Elixir, can run code dispersed on thousands of machines, and is the same base layer chosen by WhatsApp, Discord, and Telecom of old. Elixir and similar langs are making inroads to webassembly through AtomVM.

A bunch of pixels (electrons?) have been spilled in discussion of client-side libraries, rendering pipelines, and the issue of a dense bundler landscape.

These are the pieces that I feel I needed to learn, simply to build at the level that an end-user expects.

Since my first company in 2017, I had the idea that a single human should be able to harness the energy of machines to build useful apps, and fly in the face of the market and industry if needed.

There are too many apps that I'd like to build, to choose only one; so I focus on the process of app-making.

As a consequence... I'm ready to build a seamless channel from GPU to GUI, so people can build and share from any machine, either in a board room or on a beach, in café or construction, factory floor or farm field.

With all the chaos of change in the air these prior few years, I'm sure the remaining online boom of the 2020s has to focus on education, to rebuild a common language around our programs, and condense new labor pools from the displaced employees of the recession.

Only, am I going to be the one to lead the lesson?

No; I only know code and how to apply code to build programs. I'd like to learn from others, people who manage more serious problems than code. The program is designed around helping people share and discuss their learnings, in any discipline.

I spent years helping people, young and old, learn code - and there needs to be a clear place to land once a child outgrows Scratch.

I spent years among lawyers learning the nuances of the business - and they need an app to change a spare GPU into an on-premise pipeline.

It is impossible for our machine learning apps to find - or build - audiences that resemble the era of blogs, consumer SAAS, or B2B products. In a sense, 'audience' is no longer meaningful.

We need to keep in mind that a "Fortune 500 Product" is now being challenged by a $500 ebay purchase.

We need to realize that anyone can build, if they have the space.

We need to make space to build.

A bunch of our daily experience on our processing machines is managed by online browsers; these commonly run packages of code that they demand on-the-go from relays positioned across the globe.

This is probably the single most compelling mechanism of modern human communication, and the idea is so simple and reliable that we've come up with many incredibly nuanced modes of description for the phenomenon.

To begin, the packages of code that are handled by your browser app, are composed of a few languages operating in harmony;

• .html: hyper-text markup language
• .css: cascading style sheets
• .js: java-script

These have been around for years, to the degree that if someone who has never opened a code editor happens across a broken web page, they are likely to be able to say which of these three languages the error has occurred in.

Although the boundaries among these languages are becoming uncommonly blurred, mainly because of the promiscuous dalliances of .js in the business of the others, there seems to be a baseline recognition of the purpose each one promises to uphold.

To speak more of these blurred bounds; the three languages are normally passed from a relay to a consumer's machine in seemingly a single moment, and to keep this exchange as quick as possible, millions of engineering hours are poured into a problem space called "bundling".

A quick index of the different bundlers through the years; because they more or less accomplish the same aim, and are designed to be unseen and unheard, they become remarkably interchangeable until one of them fails to keep up with the pace of change.

• Grunt
• Gulp
• Rollup
• Parcel
• Esbuild
• Vite
• Deno bundle

To dramatically complicate the scene, this cambrian explosion is echoed on the opposing side of a coder's experience: how to manage the dependencies of a code base, that one's app needs to rely upon, and that are bundled up alongside the bespoke code in each app.

This problem is called "package management", and for the web space the canonical package index is npmjs.com. The process of sourcing and arranging your dependency packages can be managed by numerous programs also, such as:

• npm - node package manager
• bun
• deno
• yarn

Yikes, oh no.

Finally, there is one more layer of choice that a coder needs to make:

The bundling process, from beginning to end, is all managed using JavaScript, although the more dedicated engineers among us have learned to build the core machinery in a quicker and more reliable language, usually Rust

Now, all of this code we chose to depend on needs to run somehow, and JavaScript is considered to be rather loose around the edges. Rather than a single simple engine to run this programming language, the language is being pulled in many different directions, because in essence each browser has a company of people behind the scenes, building new ideas into their own javascript-running engines, to get the lead compared to their competition in market niches like mobile phones or media streaming.

So, again in a gradually changing landscape, these execución engines are:

• Node.js®
  • based on v8
• bun
• deno
• wasmtime - for special cases.

Having said all this, I can proceed to make a choice among the options that I may be happy to build upon for years to come, and that I may be equally happy to recommend to my peers.

Node.js® (node) had been the original engine in the bundling space, and prior to its release the JavaScript language had only really been used in web browsers. This becomes clear by examining v8, which had been running in the Chromium code bases long before being repackaged into node.

Although basically enabled the bundling scene in the olden days, node seems to be lagging behind especially in the package manager space.

The included node package manager, npm, began to see doppelgangers appear years ago, such as yarn, which promised to be more secure and speedier, with additional debugging features for thorny issues. This promise played out as planned, and yarn is as ubiquitous as any choice these days.

I used yarn for long enough without looking deeply at the code, and I essentially assumed that the piece would also be replaced someday, especially as rust libraries became more popular. Sure enough, bun took a huge leap ahead, and replaced both the package manager and the engine in one go.

For a while I had no need to make a change, until I began a more serious examinación of local-first apps. Suddenly, the bundler problem was the problem, numero uno.

I eagerly applied bun to my peculiar mix of build codes, and although the package manager was running splendidly, I was able to make no progress on the bundling problem - for a scary span of time. Months. Seasons. I could build, but I kept feeling things break in ambiguous directions, and it was only this morning that I finally pinned down the location of the problem, in the middle of this mess.

You see, coders have no patience; we know that our full career is a race, both against our younger leaner competition who are spoiled with more graphics cards, and against the carpal tunnel syndrome we incur, and beckon on with each keypress.

The bundlers we use to build and ship our online apps decided to help here, and they came up with an idea called hot module reloading. In essence, the bundler realizes that to make an app, a coder needs to see what they are making - and the bundler is standing directly in the path from code to rendered page.

It is only good manners, then, to help open the doors in the corridor; on each file change that a coder makes in their editor, the bundler is commissioned to sense the change and reload the browser.

In essence, this reduces the price of making each change by nearly 6 key-presses:

• [cmd-tab] to change to the browser
• [cmd-r] to reload the page
• [cmd-tab] to regress to the editor

When recording a file change requires two key-presses, a coder can measure this as 75% savings, on a procedure that needs to happen hundreds of times a day. Beyond silly numerical measurements, this is the kind of change that makes people happier, in their employment, and ensures that they can keep their precious focus on the problem they are hired to do.

If you'd like to discuss burnout and demoralización among open-source coders, drop a reply. There's an endless discussion that needs to be unleashed.

So how did I reach my burnout phase for bundling?

I realize this is a core piece of the program I need to build; to run locally, an app needs to be bundled for local consumption, and there is no way of escaping the reliance on a bundler these days. Even good desktop apps are based on this process.

But I had no confidence in the bundlers I chose - and the problem was hidden from me.

Everyone raved about the bundler Vite, saying things were good to go out of the box, and there was no end to what you could do.

In practice, I could not even get the page to reload consistently.

• I could bundle the code, and see the rendered page.
• I could make a change in the code, and the page would reload.
• Any additional changes to the code were ignored.
  • Even a manual browser reload ignored the changes
  • I had to re-start the bundler command to pick up any changes.

I sensibly assumed the problem was the bundler, and looked through the dependency - chokidar.

Being based on NixOS does mean that occasionally things like this break, but that was odd to me - I had gone through this before, which is why I now include the inotify-tools package as a dependency in each of my flake.nix files.

Besides, the first page-reload does imply that chokidar sees the change. Infuriating.

A few months ago I traced out the course of this issue, and realized I was trying about eight options in parallel, without reliably tracking my methods.

This round, I began to add rigor using git branches:

* 3f65b69 [bun] rearrange dependencies.  (HEAD -> marko-manual)
* 95f0047 [marko] manual setup using v6 docs.
| * 9610601 [esbuild] begin adding bun commands.  (esbuild)
| * 5b88e2b [esbuild] manage `esbuild` using nix.
|/
| * 9be1bae [vite] dead-end using `vite_phoenix` and `lit`.  (vite)
| * 8645b56 [vite] add `vite_phoenix` hex pkg.
|/
* 5d4c6d9 [bun] add `bun`, manage libs using nix.  (base/main, marko-a, marko, main, lit)
| * cfd6339 [marko] reach a dead-end based on numerous guides.  (base/inert-marko, inert-marko)
| * b130e92 [inertia] clean up rough edges.
| * 7e5f9c6 [tailwind] use nix-managed `tailwindcss_4`.
| * 8ffe251 [bun] use nix-managed `bun` binary.
| * c00ff15 [inertia] copy in nordbeam/exinertia-templates
| * cec3f19 [inertia] igniter.install exinertia, #3
| * 1e6633d [inertia] igniter.install exinertia, #2
| * 18662cd [inertia] igniter.install exinertia, #1
|/
* 14747ff [nix] add `flake.nix` & `flake.lock`
* 07d71f3 [base]> nsh elixir mix phx.new operable

After a full day of this I was angry and sad and depressed again. This is a damn easy, "step #1" kind of problem for many people. On top of my money problems, the only amusement I could find as I cried to sleep in the rolling boat was to imagine the experience of sinking, tied to an anchor.

The silicon machines I am beholden to are made from crystallized sand, and I am fond of saying that on many days, composing in this landscape feels like building a house on quicksand.

Luckily, as Shakespeare describes in "The Tempest",

We are such stuff as dreams are made on, and our little life is rounded with a sleep.

At risk of misinterpretation, my little (sub-microscopic) problems were indeed rounded out by refreshing my memory in dreams.

When I rose this morning I plunged once more into the quick-sand-scape, and picked through each thread I had arranged out the day before. Then I recalled a small conclusion I had reached months ago, and failed to record in my exhaustion at the time.

Changing back to yarn and node repairs HMR using vite on nixos.

If only I had found this phrase somewhere online, or in the responses of some desparate GPT bot chat, I'd be holding on a small measure of hope today.

I know that nobody reads these blogs for the emotional dialogue included, because I also search, find the clue I need, and close the page.

I record my mood mainly for a reminder of the pains when no such clue exists online, and days can be spent spinning in circles on anchor, hoping for some manner of release from the silent building anger.

Bun, fix your shit.

Maybe I'll have more fun riding a denosaur.

On my long sailing expeditions, which can take a week or more to measure the same distance that a car can run in an hour, I rely on my propane grill for cheer, and my chosen podcast dialogues for company.

Yesterday, caught up in a flurry of programming errors and managing a video call to relaunch some sleepy machines, I pressed pause in the middle of Seph Gentle's Local-First Podcast interview.

I had the pleasure this morning, as I plugged the 5g modem back in, sipped my coffee, and logged on to manage my corporate financial crisis, to hear Seph describe some really compelling ideas that ring loud and clear in my ears.

Since coming to DC I have had a serious challenge in finding peers who obsess on their programming language opinions in the same manner that I do; the impulse to sign on to a corporate contract is usually how people end up in this area, and any nascent start-ups here have only the machine-learning boom to credit.

This example Seph gives, at around 1:14, seems like a clear summary of the problems I hope to challenge, bridging the domains of legal policy and online policy, where communicación norms are being chosen in a clearly un-democratic manner:

The cloud always feels like... feudal city states, you know? So back before we had democracy, and before we had countries, you have these towns, and the town? It's not a democracy; there's one ruler, the noble, the local noble. And if you upset the noble, there's no laws necessarily; that's a recent invention.

The noble would say, no, not you. And you'd either be exiled if you're lucky or like, you know, hung from the town square, if you did something the noble didn't like.

And no one owns property. Only the noble owns the whole town. That's the rule, right? And so if you have a house, you have a house because the noble has graciously allowed you to live there. And that's the rule, you know?

And if the noble wants to do, whatever they want to do, There's no higher law than the noble.

And that feels like the software ecosystem that we exist in today, where, you know, there's the Google city. And as much as I have endless respect for so many individuals that I know who I've worked with at Google. I think they're amazing people.

But - the experience is Google is a feudal city state. Where you walk into the gates and if the noble, if the local Lord doesn't like you, then you can get banished at any moment out of Google.

There's no recourse. There's no laws. There's no rules. It's not a democracy. you don't have any privacy. Everything you do is monitored 24/7 by the Google cameras that exist everywhere.

You know, in their nice little plastic, you know, beautiful designed, whatever.

And if you don't like it, you can go down the street to the Apple town where everything is run by Apple and Apple has slightly different values from Google. And I happen to like Apple's philosophy on privacy more than Google's, but it's the same kind of world.

And I personally believe in democracy, and I like that my streets aren't owned by a company, call me crazy, but yeah.

And I don't know how it interacts with AI, but I feel like we've got, I don't know. It's like, we've got this opportunity to being more creative, to make more stuff, to not need billions of dollars of funding, and it's up to us what we want to do with that.

There are some ideas that compel because they inspire, and there are some ideas that compel because they scare.

So much of the corporate landscape online is focused on inspiring people - as an example, I clicked through the landing page of n8n a bunch in the last couple days, and their product branding seems to promise the capabilities of either Thor, The Flash, or Shazam.

So, no one needs a reminder of why techies are seen as children.

2025 is here, and all of us agree that we woke up to a hellscape. Here I am, falling asleep on the Chesapeake Bay, and looking out on a horizon that is as smog-filled as the Beijing weekdays I remember from 2013.

All of us have made connections to friends from across the globe, simply soon enough to see their neighborhoods pummeled by bombs into rubble on our media feeds.

The rate of censorships from our own government this year has us asking if 1984 really could be a simple 40-year anachronism, rather than a spooky and silly dystopia.

So I'm happy to be holding onto a real idea here, that our communicacións are more or less broken, because of decisions made decades ago that should be more challenged by the public than they are.

Of course, I need to think of how I can lend my skills to this scenario.

A couple minutes before the feudalism discussion, Seph raises the issue of Dharma:

there's this idea of Dharma that's talked about, in some Eastern philosophy, which is like, what is the duty that's your sacred duty? That's yours alone to reach.

And that duty, by the way, might just be to like, be a really great parent. It doesn't have to be anything grand or grandiose in any way, but asking that question of what is it yours to do in the world? That's yours uniquely that no one else will do if you don't do it.

I think that's really the question that we want to be asking ourselves as creative workers.

Of course I am unable to nicely ask Google or Amazon to please explain the business purposes behind their legal agreements. Please give me a chance to read through them before deciding if I should sign up for another email provider. The busy-ness of our lives, the quick pace we all embrace and rely on, keeps us from yelling about the abuse, keeps us coming back to the same horrid relationship that gives us the sense of reward we crave.

In the end, domestic abuse is also how dogs were domesticated. I'm far too much of a lone wolf to obey capricious calls from an alien lord, in exchange for gaudy toys, and saliva-inducing snacks.

So I bounce and roll around on the sailboat (the spin from shade to sun now indicating that the tide is changing, and I should be going), and I consider how to arm the peasant rebellion, in 2025, using code and phone and new languages of expression.

I am the one on a soap-box, largely of my own making, yelling in the town square of the impending bloodbath.

The wages of our labor, spelled out in songs and images on screens across the globe, are of course becoming repurposed behind the horizon by managers in a board room, who run the psychology experiments using the metrics of click and spend, cheerfully ignorant of our basic unmet needs, as we ride to anyplace we can call home, in a subway car beside someone tuned into a streamers popping head-shots and yelling obscenity into the abyss.

The escapism we are being sold is supposed to inspire? No; speaking of scary.

LEGEND:

In case you go through the backlog on this domain you'll likely see some real ad-hoc pages, ones that seem to be leading no place, more poetry and emoción and inercia, than prose and progress and momentum.

I guess the problem had been, ideas came and were gone too easily, too soon.

Before now I had no place to map out my plans;

I produce this plan using the superb D2 language, and re-compile on each published change to gram:page.

Here is the diagram source, referencing each sub-diagram.

Current plan sub-diagrams

OPERABLE: BASE: NODE: BUILD: MICRO: GRAMME: LEGAL:

Some more, sidelined sub-plans:

OP: LEDGER: BIO: MEDIA: PSQL: HEX:

So, you're managing WordPress?
That's a popular thing to be doing!
How long have you had this running?

Oh, how rude of me to ask; probably much longer than you'd like to admit.

Here is how you can quickly back up a WordPress domain - focusing on the content of the pages, rather than the themes & style.

Throughout this guide we'll be making use of the WordPress REST API. Our code samples are prepared using Nushell.

Discover the API.

WordPress relies on a discovery mechanism to communicate each site's public API to one another.

In this example, we use wordpress.org - the same code applies, in theory, to any wordpress domain.

def "wp base" [domain: string] {
  http get --full $domain |
  get headers.response |
  where name == link |
  get value.0 |
  parse '<{link}>; rel="https://api.w.org/"' |
  get link.0
}

let base = wp base https://wordpress.org | tee { print }

Solid! We have a base URL.

Using the reference, we see that /wp/v2/posts is the path we need to use.

Depending on how your WordPress has been managed, other nice places to look are:

• /wp/v2/pages
• /wp/v2/tags
• /wp/v2/categories
• /wp/v2/comments
• /wp/v2/media
• /wp/v2/users

Again, see the reference for a more thorough appraisal.

To help us progress here, let's make a couple quick helper functions:

def "wp dump" [base: string, path: string, --form (-f): string = yml] {
  let node = [. ($base | url parse | get host) $"($path).($form)" ] |
    path join | path expand
  mkdir ($node | path dirname)
  try { http get ([ $base wp v2 $path ] | path join) | save -f $node }
}

Ready? Here goes.

let base = wp base 'https://wordpress.org'

timeit { [
 posts pages comments media users
 categories tags taxonomies types statuses
 settings themes search plugins
 block-types blocks block-renderer block-directory/search
] | each {|label| wp dump $base $label } }

# for a colleague's domain:
# 21sec 895ms 964µs 817ns

Of course, if you prefer a non-yml dump, pass in one of these extensions under -f:

➜ scope commands
    | where name starts-with "to "
    | insert extension { get name | str replace -r "^to " "" | $"*.($in)" }
    | select extension name
    | rename extension command

╭────┬────────────┬─────────────╮
│  # │ extension  │   command   │
├────┼────────────┼─────────────┤
│  0 │ *.csv      │ to csv      │
│  1 │ *.html     │ to html     │
│  2 │ *.json     │ to json     │
│  3 │ *.md       │ to md       │
│  4 │ *.msgpack  │ to msgpack  │
│  5 │ *.msgpackz │ to msgpackz │
│  6 │ *.nuon     │ to nuon     │
│  7 │ *.text     │ to text     │
│  8 │ *.toml     │ to toml     │
│  9 │ *.tsv      │ to tsv      │
│ 10 │ *.xml      │ to xml      │
│ 11 │ *.yaml     │ to yaml     │
│ 12 │ *.yml      │ to yml      │
╰────┴────────────┴─────────────╯

For completeness, here is a multi-format dump:

let base = wp base 'https://wordpress.org'

let labels = [
 posts pages comments media users
 categories tags taxonomies types statuses
 settings themes search plugins
 block-types blocks block-renderer block-directory/search
]

let forms = [ csv json yml ]

timeit { $labels | each {|l| $forms | each {|f|
  wp dump -f $f $base $l
} } }

Yeah! Such a nice backup already.

➜ tree wordpress.org
wordpress.org
├── block-directory
├── blocks.csv
├── blocks.json
├── blocks.yaml
├── blocks.yml
├── categories.json
├── categories.yaml
├── categories.yml
├── comments.json
├── comments.yaml
├── comments.yml
├── media.json
├── media.yaml
├── media.yml
├── pages.json
├── pages.yaml
├── pages.yml
├── posts.json
├── posts.yaml
├── posts.yml
├── search.json
├── search.yaml
├── search.yml
├── statuses.json
├── statuses.yaml
├── statuses.yml
├── tags.json
├── tags.yaml
├── tags.yml
├── taxonomies.json
├── taxonomies.yaml
├── taxonomies.yml
├── types.json
├── types.yaml
├── types.yml
├── users.json
├── users.yaml
└── users.yml

If you have a local copy of zip, yay!

zip -r wordpress.zip wordpress.org/*

Since I'm on NixOS I'm going to use a small prefix here:

nix-shell -p zip --run 'zip -r wordpress.zip wordpress.org/*'

Now, I'm going through this process to help a colleague, so this is a good place to email off the ZIP file, to see if she has any issues with how the records came back.

I'm eager to press ahead and look at a few newer CMS options for her! A couple ones I already have my eye on:

• Beacon
• Solid & MDX

Plus, the Awesome SelfHosted page has 40 more options for a CMS upgrade - of course, including WordPress.

HOPE you're buying a pass also.

A day ago I discussed a broad plan to rebuild ://operand.online; the challenges are already becoming clear. All the same, some progress!

I focused today on the first motion necessary to upgrade the blog - changing from the clunky share.operand.online to a real git relay, so that someday I can run git clone to copy the markdown to the web client, where I'll rely on SolidJS and MDX to compile the pages.

The essays are in gram:page, the web code is in gram:op, and the deployment code is in gram:build.

So far I'm doing all of the rendering for the essays in Elixir, a fabulous language that has a higher calling than the rendering of markdown.

To change this, I need to first focus on deploying a new relay program, called soft-serve; you can ssh git.charm.sh as an example, or see my deployed copy at: ssh -p 2202 base.operand.online. I recorded a console session as I hooked this up in NixOS.

Now, the relay is up and running. Yay! That is as far as I made it, because the next piece is so uncommon.... that no one really goes that far yet. This is the cool, unknown-frontier piece of coding. We're gonna be in a danger zone from here on.

To be specific about today's errors that are holding me up, I'm seeing different problems locally and in deployment.

Locally, there seems to be a CORS error when I make a connection to https://base.operand.online - an HTTP 405 "Method Not Allowed". I see someone else added code to handle this problem, and somehow it does me no good. Perhaps the issue is that on my local machine, I am running the app on HTTP rather than HTTPS. CORS (cross-origin request security) becomes picky on such conditions.

So, I merged my branch into main and pushed - and the compilation broke because in 2025, compiling to webassembly remains a hard problem somehow. I'm usually amused when I see errors decrying a bad "magic number"; though today I am less than amused - I need this connection.

Now, libgit2.c is a shady binary to compile to webassembly, because the compilation target has been pinned like a donkey-tail to the braying ass of a language.

If I'm going to proceed, I'll be much happier using GitOxide, since much less can go badly when cross-compiling Rust, and I'm beginning to learn a sense of the language tooling.

I'm surprised to say that I'm no longer scared to dig through Rust code - somehow speaking to a bunch of open-source coders who depend on Rust makes the language seem more human, more approachable.

My textbook from No Starch Press has no mention of webassembly, though! I'll be choosing from some capable blog guidance. ( 1, 2, 3, 4, )

Although the blog rendering procedure remains unchanged, I now have a new git codebase relay up and running, happily secured and managed using SSH, and honoring my user SSH keys.

I can now confidently synchronize code again!

Since I spun up the "baseline lab" in Maryland, I've been doing a bunch of on-relay code changes, especially for the code I'm using to clone static.case.law.

Those code changes are soon going to be added to the gram:build codebase, although I'm not looking forward to the merges after a few weeks of divergence between my laptop and the lab.

Sundays are my de facto day off, based on library schedules, and I'm lucky to be busy tomorrow with the Denver Pride fest. I'll sign off here and hope to be back on Monday, sharing anything I picked up around Rust and WASM in the meanwhile.

The days passed quickly!

Because being precise in the midst of such a blur is impossible, I'll relay that I had some really good discussions! Only some of them concerned linux or open source.

Somehow, my Hyprland desktop came up and someone mentioned that the lead coder has some... people issues, as so many of us do.

Because I missed the day 1 description of Cosmic DE, I changed a couple lines in my Nix configs and after a long, conference-wifi download I was up and running. The keybindings make basic sense, and I'm making progress as usual.

Somehow System76 has no presence in the sponsor's playground, so I spent a piece of an hour speaking to Framework! They had their new touchscreen on display, alongside their desktop and a sleek rack-mount 4x desktop lab. The 16" input modules are some peak engineering; I had an engineer run lsusb as he plugged and unplugged them. I'm super impressed, needless to say.

Incidentally, the Framework lads had been amused to pull up my old Jira ticket - on Jan 4, 2022 I had been the first order shipping to Washington, DC; I asked someone to add the district to their e-commerce form.

In the middle of the conference I paused to message one of my collaborator groups on Slack:

Hi, clicking in from the Linux Open Source Summit in Denver; A couple people are discussing distributed (dispersed) data lakes (record collections). These include:

• https://lfedge.org/projects/edgelake/
• https://gravitino.apache.org/

these options are groundbreaking ways to solve a problem we may have someday: connecting different databases and sources.

Our lab-location problem is more properly called "High Availability" or "Disaster Recovery". The usual approach is to combine "Replication" and "Failover". This normally requires reading long incomprehensible explanations:

• https://www.enterprisedb.com/postgres-tutorials/postgresql-replication-and-automatic-failover-tutorial

We can be unusual though!

This open-source DB is designed to be multi-machine, and a drop-in replacement for postgres. The other apps like Airflow or Tableau should have no idea the underlying program is changing.

• https://www.yugabyte.com/
• https://github.com/yugabyte/yugabyte-db

And speaking of Slack, I am a new member of some buzzing new groups: OpenSearch and CHAOSS.

Now, in the 4th-day mini-summit, I'm on the special CHAOSS track. After a couple days of high-IQ discussions, I found some refuge in discussions of docs, inclusion, onboarding, and the more human sides of open source management.

CHAOSS is the main group appraising open-source health on a global basis. They produce education programs and open-source apps to help us explore the science of coding, using the public records of authorship inherent to open-source.

Today is a deep examination of how to measure open-source community.

Phase one in the process is to mine the rich resource collections: you can use GrimoireLab or Augur. Augur is the source behind 8knot, a dashboard core to CHAOSS.

One of the speakers mentioned having authored a blog post for opensource.com, which seems to be experiencing many Drupal and AJAX errors!

I'm in the middle of an employment application as a Drupal manager, so I may seek to help on their app if possible. Oddly enough, I see no source-code links among their pages.

These authors mentioned the Cardano blockchain as a peer-reviewed blockchain geared towards paying open-source coders. Yay! These speakers also authored Mozilla & the Rebel Alliance and similar reports examining community relationships.

I'm marginally sad to have missed a discussion on Ecosyste.ms, and eager to explore this domain more as soon as possible. I had absconded from the CHAOSS track for that talk, to go see how to apply Guardrails for AI apps.

Hopping back to Tuesday as I examine my open pages, I had been super pleased to see the author of Wireshark explain StratoShark, an analogous program he has made to explore system calls.

The key idea behind this program is to be essentially a clone of WireShark; the .pcap capture file for packets uses the same encoding as the .scap files for system calls. The audience asked around the possibility of building an app, perhaps a web UI, to display both captures in chronological order.

"Sure", he said. "In the base of the repo there is a sharkd daemon, and someone has had success communicating to that process from a WebUI before." [paraphrased]

Now, I'm sure more is going to emerge from this conference in the days to come; I'll spend many more public-library sessions in my email inbox and blog, perhaps uploading images from my camera.

Which reminds me - I had a chance to ask a Sony patent engineer about my Alpha DLSR; we discussed how nearly all serious camera companies are made in Japan, and we double-checked where [Hombu Dojo] is (Shinjuku).

I need to spend much more time learning Japanese, and besides, this may be the primary appeal of the Open Source Summit; the highly international audience in attendence.

I'm making connections, and am eager build a much broader dialogue around these ideas in the days and months ahead.

The Linux Foundation's 2025 Open Source Summit launched today, at the Colorado Convention Center in Denver - where I've spent the last day collapsing on the ground and engaging in Wim Hof breathing exercises, to simply remain conscious through the day and recuperate from many long hours on the road the prior week.

I am spending the conference camping in my pickup during the nights, and have access to $150 or so for the next week. I'm passing up on some of Denver's cuisine while I'm here, although I am eager for a biscuit somehow. I'll address the money issue soon enough.

So, rather than park in the conference center for $25/day, I spent the morning in my brother's Boulder home rearranging the cab, then found a place to park in Paco Sanchez park. I rode my bicycle in for the lunch hour, missing the main keynotes.

The lunch had been arranged inside the sponsor gallery, so I'd been pleased to run into Ericsson telecom - the company behind Erlang (crucially underlying this domain), and Automattic - the company behind Wordpress.

I told Ericsson's rep that they need to sieze their chance to build a YouTube clone, using Membrane (or, perhaps in a less captured market, a video compositor?).

For Automattic, I began discussing the issues I had seen spread across a number of LAMP-stack applications; the core ones being: Wordpress, Drupal, and MediaWiki.

I'd been super-pleased to hear that in my quest to export a bunch of Wordpress domains for re-use in other CMS harnesses, I'd fully overlooked the public REST API built into each Wordpress domain.

This alone is a breakthrough that is considerable for my purposes - I had reached a similar approach for exporting Wiki pages, using the built-in Special:AllPages and Special:Export combo.

Realizing that there is similar, fully public access to Wordpress pages made my day before it really had a chance to begin.

Since the vegan lunch also sacrificed gluten from the bread recipe, I peeled the foam off of the sandwich and nibbled down my salad before loading up the schedule and preparing for my speed run.

The main themes of the day seemed to be:

• Software Bill of Materials (SBOM)
• AI hype of course
• Embedded deployments, mainly using Zephyr

SBOM concerns are most closely related to my government focus, because they are crucial for supply-chain appraisal and security assurances. Alongside those talks I sprinkled others, such as documentation and continuous delivery, as I dashed from room to room amid the hallway overflow discussions.

One talk focusing on open-source hardware examined ProtoCentral, and the HealthyPi boards. The health focus of his group is super aligned to the engineers I collaborate with each week, and as I become more engaged in making I'd like to crack in to one of those boards - perhaps the mobile option.

The next speaker I chose had been discussing SBOM approaches, and recommending how to respond to the endless cascade of CVEs published each day - the vulnerabilities all of us dread.

The group leading the discussion had been DeployHub, and I picked up links for bomctl and Ortelius. The speaker had been asking for 10 users to lead an adoption study, so we exchanged ideas and are planning to discuss tomorrow how to de-bloat an application's dependencies. I'm eager as can be, and introduced by email before the talk ended. I also need to look up OpenSSF, as a related group here in Denver.

Then began the conference zoomies, because I sat down in the hall and pulled up each talk for the next hour, chose the compelling ones, and mapped their location in the hall.

Then in no real order, I peeked in on:

• The TODO group - advocating for corporate recognition of their open-source obligations.
• Open Mobile Hub, a panel with no real cohesion and an unsure mood. Meh?
• OpenSearch, which may be the only laudable product I've ever heard promoted by an Amazon engineer. The open-source program seems to have minimal corporate reliance.

Then, once I thought I'd been done for the third time, I found the CD Foundation. The discussion here was led by the Edge Monsters, and they had on stage a real, running mobile lab - seemingly pulled out of a Pelican case, and ready to be loaded onto an airplane.

One of the speakers, a member of the Air Force, claimed that the lab had been to 7 countries, in over 40 demos - and he happily pulled different blades from the rig with no ceremony, sure that the balance would be rearranged in the absence of 1/3 the silicon resources.

There was some impressively granular discussion of the components, although more happily the design has been approved for open-source release... soon? I need to email to double-check the link and release plans.

So concludes the open source summit day 1. I'm happy for a chance to record many of these experiences before the convention center closes in... 10 minutes.

I'll need each spare second to run the 6 miles to the other side of the building, by the blue bear, where my bike is parked, before picking up some dinner fixin's at the local Sprout's.

Is a really big building, and the peaks look good from up here. Perhaps more pictures to come - for now, big ideas to explore.

I commonly come across programs I'd like to use.

I load them up, begin running them for a day or so, or perhaps only a couple of hours, and quickly decide.... nah.

The programs could be good, and be-longer in use, and belong in my arsenal, only they lack some pieces I require:

• More and more, I need my programs to be local-first (LoFi) to keep up with my nomadism.
• My programs need to be open-source so I can change them.
• My programs need permissible licensing so I can keep them running.
• My programs need to be free. I am an economics essayist, hence dismally broke.

Here are how some programs compare on the rubric:

From looking at this graph, you could properly assume I am much less able to organize my ideas as I am to execute on them.

Each day I begin doing something or other, probably using Nushell. I quickly realize I need to build a cleaner experience, and build up a couple uh, new shell functions - maybe 5 minutes, maybe half an hour.

This is a nice approach for me because I've accumulated a big bunch of functions I can rely on. I re-use them again and again, and my progress gradually speeds up as I go. Of course, I basically only use Nushell... for anything I need.

This is one of the reasons I'm so amped up around AutoMerge. The promises made by [Patchwork] seem to echo all of my ideals, in a nice clean vaporware all of us can idolize prior to release.

Maybe I need more solid benchmarks.

All the same, my nushell command bundles are reaching a place I'd like to expand on; and bring into my normal web-app procedures.

I'm making pushes to help more in nushell, and some of the additional core codebases I depend on. As automerge progresses I'm keeping an eye on the discussions; the research is beyond my usual relaxed pace.

Of course, I'm learning Rust as I go, and my leaning towards the language is pulled by my happy experiences with programs rather than an ideological language theory. The Rust-based programs I depend on are simply quicker, easier, and more reliable. More snappy.

All in all, the idea I'm most on board with in the [AutoMerge] landscape, is the "malleable software" goal.

I'd much rather use a collección of small programs I can easily rearrange on a whim, than spend hours or days repurposing something collosal like Blender into a usable process.

This is one of the main issues keeping me from progress on animation, or video editing. Some of the programs are good, all are bulky. I'd like to see core building blocks in a performant language, repurposable on demand at least to the degree that gstreamer had been. My price point aside, there is a large market for cross-platform animation, demanding to be filled. The incumbents ignore full OS channels, while falling behind on any use case beyond their chosen primary mechanic. No coincidence that there is such a chasm separating animation from graphic design, when at first blush they seem to be close siblings. Imagine how much may change if that one boundary could be bridged.

So, as I go I'm going to look at core Rust libraries for vectors, for graphics, for sequencing and animation and paths maths. The changes are going to come some day, and for a long duración they are going to be unable to compare to the prior generación. Their only hope for success is to build up core libraries, piece by piece; imagine if raylib became a core dependency in a large range of programs, and how many chances for interoperable exchange such a scene could bring.

Only dreams so far, although I've been ignoring the hype cycles long enough, gradually building up my lonely basis, that I feel I can reliably lead this charge.

One of the main issues needing to be addressed here?

Finding small, re-applicable problem descripcións able to be cleanly handled by a small codebase. Proliferación of solucións is both desirable, and inescapable once a small problem is comprehensively labeled and scoped.

And speaking of scope, there's news to announce this summer, once I reach the Linux Foundation's Open Source Summit early next week. I need to do a small measure of finagling to bind audio to an Asciinema recording.

This announcement follows the recipe; I looked at the problem I had been trying to address for nearly 3 years, using NixOS and Nix Flakes. I call this problem "reproducible deploys". I examine how the problem space is riddled by incumbent challenges, and I cleanly arrange a language to bring more meaning to the space, using common analogies already popularized by today's popular deployment languages.

This language is called scope, and I'm more than thrilled to have hashed through the basic language design at Baltimore Node on Thursday night.

Language design is one piece - I need to learn a bunch of Rust to apply the ideas. Only... now that I realize the issue, the "bunch of Rust" has a clear purpose, and seems easy to approach, and is mainly only a basic dependency graph to encode and decode.

I'm sure there's a small package of code I can re-use for the purpose...

As I go along, in my career, I come across good ideas.

I rarely produce any of the caliber I see becoming popular online, so I become good at learning the currents around me, riding on the tide of popular opinion, and adopting the drills and exercises of my peers.

Some people call me a mimic; this is fine.

Today I am looking back at my progress for the preceding year, and I am realizing - there have been many false launches, rugs pulled from under my feet, and otherwise unpredictable occurrences keeping me from producing. Sure, I keep sharp in some domains - and occasionally I am able to build a solid base, such as this essay engine you are reading, only - as soon as I'm done building, I back up from the program and examine.

This Elixir app is nice. There are a couple unique, bespoke pieces. You can change color schemes, and it reads source from git directly.

Those shiny angles are pleasing to me as a builder, only they are rather silly in comparison to all of the shiny gems I've passed up as I focused on this path.

As an example, I opened up a large box, labeled "Pandora" - and a menagérie of local-first designs leaped hence.

As I explored the curious animals in this terrarium, I came across one such who had compiled git into webassembly.

Amazing! Here I am, forcing you to ask my machine to read a codebase for you, and relay the measures of code page by page.

Much simpler, here, to use the normal procedures for sharing code, and help your machine learn to parse and display the pages locally. And so, my gleaming aims of 2024 are seeming pale and dull already.

And alongside, I had imagined dynamic programs, helping many people collaborate "on the same page". Elixir and Phoenix are a superb approach to reach this baseline, as I experienced. Only... they grew up a'fore my eyes.

ElectricSQl became a drop-in engine able to bring your records to users, and immensely more usable alongside browser JavaScript packages than the cludgy Phoenix Hooks paradigm I had been using before.

This comparison, indeed, made me reconsider some of the compromises I made along the road. How did my apps all come to look bland, seem similar in appearance, and lack a unique flair? Ah, the prevailing Tailwind of the day.

Once I caught hold of the breeze, I fell for the allure of speed, and had no eye for the rocky shoals ahead. Here I am, praising color changes on an app, when all of my styling rules reside in a single .css file.

In olden years, I'd harp on co-located styling rules, and had even charted courses through web components, the shipping lanes of the large corporate fleets.

And ho! Is this no less than the approach made possible by UnoCSS, or the colocation explained by the solid-element plugin?

Alas, faded ambición. My searches had persuaded me that the hull I had made is shabby, dank, and dim. In any case, far from able to carry me on to far-off seas.

And so, demoralized by my small corner hole I needed to huddle in, I disconnected from the keyboard and pursued more music, essays and lyrics replacing expressions and logic.

I am sincerely glad I did so, primarily for the sole memory I earned, of being onstage, spotlights in my eyes, peering through the shine into the deep silhouettes of an audience, ready to share and bare the small remnants of soul I carry. Is a memory to seek again.

And so energized and dedicated, I come back aboard my small shabby ship, and gaze around and realize, here is the place I abandoned my depression; I see signs of the languid days piled all around, and as I doze here the old emoción seeps back and the grip seals on me.

I need be quick, decide on impulse and act in assurance, to build a road from this den of despair, and reach once again through perspire and pursuance, a small glimpse of sky and some much fresher air.

And this has brung me, by shedding assumpcións and implicacións, to consider Solid as a replacement for my aims.

There is once again room to explore, to reach far horizons, to build a base capable enough to carry real cargo, to build up a hardy crew, and to design courses pursuing liberacións more than escapes.

My ambivalence and disillusionment towards the course of React has opened my gaze to an alternative line of attack; one promising a broader channel and calmer passage, and opening up choice of dirección for any heading one could choose.

10. Briefly describe the ways in which you are involved in the technology and/or open source communities.

I am collaborating with engineers across the East Coast to build a curriculum for communications modernization, from program to policy.

Our discussions aim to bring local-first programs (https://inkandswitch.com) into legislative offices, to expand the use of secure and censorship-resistant deployment principles, and to share resources through mesh networking and peer auth.

Our association is composed of the eager learners who are commonly found in maker-spaces, hackerspaces, and public libraries. In a normal week, I can be seen in Rockville Science Center (MD), Baltimore Node, Baltimore Hackerspace, and NYC Resistor - usually drilling someone on a practical lesson plan based on NixOS and Nushell. This course has become solid enough to launch a screencast domain explaining common use cases - planned to launch on June 1.

I have a rich background leading programs, as secretary of HacDC (2023), Code for America fellow (2016), and VP of MSU's ACM student chapter (2011 - 2014). I began many of the current Congressional modernization programs as a coder in the House Clerk's office, where I began a collaboration with the House Digital Service - to build room for open-source deployments and in-house program design alongside legacy House processes.

11. Why would you like to attend this event?

Our group is under-resourced, and is beginning to align on common language and aims after years of loose dialogue. To amplify our reach, we are launching a series of screencasts to focus on the new generation of coding basics: memory-safe and machine-portable programs, designed to expand peoples' horizons, rather than bind them to a desktop.

The human concerns are something core to my philosophy - I take the laborious approach of a cyber nomad to ensure that our programs are accessible in some of the most challenging edge-cases, such as under sail and solar energy. Hackerspaces and libraries are used as kindling to spark curiosity, while connections to serious research groups and sponsors help ensure the mission remains on solid ground.

Some of our most reassuring discussions have happened in online message boards, where we can learn from groups including Ink & Switch, Radicle, and Muni.Town how to build for resilience and our common humane concerns. Our local human-to-human discussions are always engaging, and all of us are eager to bring our day-to-day practice to the builders we admire in the open source scene.

Our main hope is to decrease reliance on commercial programs offered by corporations who are more eager to sell out their consumers than help them. Our approach is to build dispersed online labs in our homes and shared spaces, to build, share, and re-deploy openly-licensed source code, and to share our skills and experience through public demonstrations: through blogs, screen captures, pair programming, and guided hackathon challenges.

As more people lend their experiences, we begin to chip down the many barriers to online communication, that keep the mass public from the education they need to make use of open source. The resources and lessons are all here; our engineers simply need a chance to engage in - and share - the practice.

Hello, Peter and Geoffrey;

Especially Geoffrey; I spent the day poring through many of your PhD publications; these seemed to clarify many ideas of user experience I'd been aiming for subconsciously. I'd like to describe a serious problem space in the middle of your three research programs: Wildcard, Potluck, and Cambria.

Of these examples, the most inspiring experience to me is wildcard - I am an enthused and eager web scraper, and migrating from Ruby / Capybara to Elixir / Wallaby has hardly been enough for me - I'd like equal access to web pages that require sign-in, or pages that make use of doom-scrolling; accomplishing these aims requires the JavaScript execution layer. Earlier, I learned some of the Gleam language by compiling a simple plugin, and I am eager to build upon this base again.

I did mess around, and had no luck spinning up a copy of Wildcard. Typescript has changed a bunch since 2021 (~1500 errors), so I am simply reading many of the modules and learning how much I can apply from the early approach. The core pieces all changed a bunch since embedded SQLite, handsontable, and bootstrap, so a ground-up rebuild seems simpler.

Sidebar: Launch Wildcard.

Spoke much too soon! I came back around to examine the error, now using web-ext to speed up the process. I also added a minimal flake.nix, so I could ensure all dependencies in a reproducible local shell.

In my normal commands, I rely on my nushell helper nd, so web-ext run becomes nd web-ext run. On a normal machine, such a command reads as: nix develop --command 'web-ext run'. These prefixes are simply assurance that all the dependencies are in place, so I'll assume you can manage dependencies on your machine and ignore the prefixes here.

yarn install
node build.js # many errors! no problem, ignore all.
web-ext run -u news.ycombinator.com

I had been really surprised that web-ext managed to open a firefox panel at all - in my opinion, the compilation had failed under the burden of endless typescript semicolon concerns. Only, there was an installed plugin in the window, and I could see in the console an error message referencing the HackerNews site adapter.

I poked around and realized that the HN markup has changed since 2021 - the selector a.storylink is now .title a. I made the change in my copy, and upon node ./build.js the running web-ext process picked up on the change.

I needed a second to realize the page already had the wildcard pane open, happily rendering all of the HN records as promised. Research needs to be reproducible, no? I'm incredibly pleased to accomplish this at the end of a 36-hour in-office research marathon.

I managed to fill a dry-erase board, merging ideas from the three programs into a single experience. From a blank browser pop-up panel, I imagined adding pglite; simple enough, I'm sure. At this phase I realized the core logic of wildcard is the bidirectional mapping, from the html page to the database table. I read a couple of the site adapters, and can see that each one maps a recognized URL into a pre-coded arrangement of columns in the table. Nice and simple, and I'd like to praise Geoffrey's efficiency in cracking these specific use cases.

Again, much progress has happened since 2021. I considered how to splice Cambria and Wildcard. In addition to mapping one JSON body to another, Cambria also handles incremental changes using the JSON patch spec. So ideal! Browser execution means open websockets, so a scraper can stream rather than poll. This is the only (sensible) approach on pages that rely on doom-scrolling mechanics. Patch streams may also help someone roll up group discussions into periodical summaries - you could keep Slack open in a long-running background tab, on a headless machine, and sync the pglite table to the eerily absent command-line program all of us need.

Yes, I realize - Cambria is JSON! Wildcard is HTML! Potluck is language! There is a challenge here, to expand Cambria to ingress / egress HTML and beyond, alongside the normal JSON use case. There is surely promise here - Cambria, Wildcard, and Potluck are all based on bidirectional synchronization, and all operate on the principle of reshaping.

Although Cambria definitions are much more specified, Wildcard uses the full JS language to apply the adapters to the page. Otherwise, site adapters and lenses share a common purpose. Additionally, both languages are deeply structured, and can be made to comply to schemas:

JSON-schema is a rich and common language for describing the shape of a JSON blob. No surprises.

HTML can be described using numerous schema languages, such as DTD - document type definitions. These are usually gnarly. The Cambria page has a (pessimistic) reference also to XSLT.

So, how do you properly consider, that - many HTML pages include embedded JSON. JSON can easily embed HTML. And these are only two of many schema-bound languages we may care to parse through. YAML and TOML are in the same mold. Markdown can include code samples in any language. And if you manage to approach plaintext documents using a Cambrian lens, perhaps you'd easily reproduce Potluck.

Here is a core issue I'd like to consider;

Maybe someday, a Cambrian lens could recognize meaningful shapes in numerous languages. In this case, do any of XML or JSON or YAML make sense to describe the lens any more? If a lens is responsible for parsing a source in one language, could the lens recognize a sub-measure of the source made up of an embedded language, and slice the pieces accordingly? How could a single lens description address changes bidirectionally (sourcemaps, maybe)? Can a logical calculation, applied to a shape mapped from any source, carry a conclusion through to the original source location (all signs say yes)? How could a schema language possibly map across numerous source languages?

Spurred by success, I proceeded to clone and upgrade gram:luck and gram:shape, alongside gram:card. All of these easily run in a local, offline mode, so I'm happy to head back to the sailboat and pick them to pieces as needed. gram:shape (json-sheets) required a small upgrade to run on Vite.

Much obliged to Geoffrey, and much more to come!

Hi, Peter and Alex;

I'm glad you messaged, especially to learn how the House of Representatives is doing business these days. I could speak for hours and hours on this theme, and I'm glad for a chance to organize some of these ideas prior to sharing more broadly on my domain.

A good place to begin is by glancing through the House XML schemas, shared on xml.house.gov.

for years, those schemas have described all ofthe legislation shared on congress.gov. You can see one of these schemas, called bill_dtd, copied into Automerge & Prosemirror code (although the prosemirror code precedes automerge, and the binding is surely lacking).

Aside from these now-legacy schemas, some composition is already happening in a new model, US Legislative Markup. USLM is far from the daily use you'd hope to see after years in incubation, mainly because of the horrid inaccessibility of the composition engine in use since 1985; XMetaL.

XMetaL has been in use far longer than any normal enterprise program, because of the organization's inability to make a sensible upgrade. WYSIWYG is top-of-mind for lawyers, and combined alongside legislation's need for a rigorous schema, and burdensome procurement policies, my first glance at XMetaL involved combing through 3000+ macros, in a combination of JavaScript, Perl, and VBScript, to bind the editor to the needs of the House. Meanwhile, the Senate procedures around drafting had diverged, producing another unique collection of thousands of macros.

After months of pain and dread caused by this predicament, I recorded my screen one day so I could remember the horrors; otherwise, this program has earned its place in the so-called online dark ages.

So, I'm sure such a program made sense in the beginning, when WordPerfect had been in common use and the internet was for email. The one serious concern to be raised about using this in the 2020's is, how do you educate hundreds of new staffers to use such a hodgepodge program, each couple years?

Uh... and so the horror becomes an embarrassment. Because no one does learn to use this; there is no congressional member office that composes legislation directly. Those staffers, and I'm sure some adventurous members, all use Microsoft Word, and then email a support office called Legislative Counsel. The LegCounsel has a couple - shockingly few - career lawyers who smush all these amazing-or-dangerous policy ideas into an amazing-or-dangerous legal schema. So one small and sad office of lawyers types all the laws congress passes or fails to pass, year after year. This old XML program has them chained to their keyboards and inboxes.

Once their draft, made in XMetaL, properly imagines the ideas from the members' email attachments, they need to clear the language with the member. So, one of the many macros is able to export a Microsoft Word document. Uh. Yeah. The draft goes back to Microsoft Word. And the drafted language .docx (I was responsible for adding the x) is marked for "Track Changes", and once again attached to an email. Clearly, the aim of this email is the generation of another word document, designed to capture any corrections the member has in mind. I'd like to say this is all handled in less than three round trips; because this is the only case in my career I've felt a need to describe NFS shares to lawyers. Only please do bear in mind the couple bills surpassing 3000 pages, proposed and passed during each year's appropriations season. If you're close to crying or screaming then you're beginning to realize the cause of Congressional unpopularity.

Ah, yeah. You're also seeing why I am so eager to make new connections; especially among coders again, and especially among those who are re-imagining applications. I made a big push as an employee for in-house program design, and I deployed numerous open-source programs on premise, all of which were met with demands from my boss to return to our vendor-contracted waterfall design process on an app to smash more email attachments, now through some proprietary Microsoft Azure pipelines. I recall some Microsoft employees being daily regulars on our planning calls, mainly to echo and encourage the one House employee who has experience deploying to Kubernetes. After 15 months, I gladly said goodbye; then took another two years to clean up the damage to my sobriety, which has included moving onto a sailboat in the Chesapeake Bay; another splendid use case for local programs on low-energy machines (see 100r.co).

I am gradually impressing upon my former colleagues that far from being bliss, their ignorance is causing their pain to progress to an incurable degree; I am also making a case that there are new approaches being made, and I had a chance to play key pieces of your LocalFirstFM interview during Tuesday's meeting. Really though, I can only describe their 250-year-old operation as a circus, dressed for church and singing to the percussion of a hammer on a podium.

Luckily, I had chances to bond connections to nearly all of the responsible support offices in the House, and momentum for change nearly always begins in the 430-member house before reaching the deliberate, languid echelon of 100 Senators who seem to imagine some quill-smudges on parchment can hold up for a quarter-millenium.

These support offices are full of people who can explain in narcolepsy-inducing depth (and indeed, my narcolepsy began here in DC) the specific causes and reasons behind each procedure - clearly mixing up reasonable and sensible. In all cases, they came to the Capitol complex in admiration of the elected paragons of democracy who demand that anyone in a support office "pay grade" shall remain nameless in any designs. Once I recognized that this dynamic causes all decisions of consequence to be shelled out; commissioned to private companies, I happily embraced the arguments that led to termination; and then quickly re-incorporated my solo LLC company as a DC corporation, able to raise nearly a million USD in capital. In essence, all this means is that I published an essay in a blog; I do remain proud of the essay.

I also spent many hours in local engineering groups, such as HacDC - where HyperDemocracy came to be. The LLM craze has all my neighbors in a serious hype, while I am simply preoccupied by how to access my coding dependencies offshore. As HacDC's secretary and one of the few who has seen the energy of an early career in San Francisco (also during Rdio's days), I did a bunch of research on where local programs are going - during one hackathon I packaged up Elixir/Erlang's BEAM VM, alongside SQLite, into a native Android app. I began reading as much Ink & Switch as I could, and I'm glad to see you all picking up your pace, as you release production apps and packages. I seriously considered ending my coding career long ago, because all roads began looking like dead ends; your philosophies share a rare coherence that leads to much more humane experiences.

As I gather courage again to aim at the issues surrounding Congress, I am also digging in on a problem raised by HacDC - the need to migrate their domain from the common combination of WordPress & MediaWiki; I'd like to enable both programs to dump pages to a .git codebase, to be equally rendered by a local offline reader (hat-tip to Aaron Swartz and the enduring legacy of RSS readers), or an online domain process necessary for search-engine propagation (and I hope we can discuss how to apportion granular search indices across machines, perhaps under sail near the Puget Sound someday).

This message has clearly become the embodiment of a deep and rich mess of problems, unique to the boundary line of aeons-old legal code, and decades-old machine code. I am seriously glad to speak to you as you consider how to mature the idea of application programming to a new generation; the nascent approaches are nonsense in the nation-building landscape. Although the 12-factor essay made for good reading in 2015, the other side of the coin has 10 commandments etched in. I clearly need nothing more than a space to share and discuss this summary of issues; it all seems much to serious for Discord and much too drab for many of the social circles in DC, where currency and security issues choke all considerations of consumer experience.

I am eager for any impressions you can share, before discussing resources. These ideas are all bound for the blog, and I am sure there are places I can sharpen or dull the language as needed.

Because there is such a deep scope in play, I'd like to coordinate among my local engineering groups before mirroring the discussions and code on GitHub or more popular domains. Peer coordination seems to be a special focus of your company's mission, so I am eager for recommendations on arranging dialogue and managing the build's progress. After years of managing the gradual decay of homelabs, my only lead is to spin up soft-serve as soon as possible.

More than anything, I am immensely pleased to add to the dialogue around these approaches - I imagine that birds of a feather flock together, simply because they're all sick of where they've been so far, can smell the seasons changing, and realize it's going to be far too long a haul to manage alone.

Building up; Calliope

Operand Company

Operand seeks to increase resilience in chosen open-source programs, including many necessary code packages and compilación processes underlying each of them.

See prior, abandoned, incorporación ideas.

Appraisal: Programs as commercial resources.

Programs need broad public reach to accomplish commercial success; meaning adopción raises endurance.

Large commercial companies rely on the success of core programs to subsidize the bills of smaller more niche experimentation. Such experiments are usually closed, and their producción ended, so long as no approach to commercial income can be seen. More unique or promising experiences may cause the publicación of research papers, on occasion.

Besides company labs, many popular onscreen experiences are produced in the open, using nearly no commercial resources - in some cases merely a thesis carried through as a hobby, commonly as learning exercises or as a necessary repair to someone's chosen processes.

Such code, called open-source, is produced across innumerable homes and offices globally, and is generally licensable for many commercial or noncommercial purposes.

Programmers need open-source codebases to keep up to modern machinery, or many cherished onscreen experiences begin a process of sublimación; no longer running on consumers' machines and no longer reproducible by peers.

Sublimación, explained economically.

Sublimación; in our descripción, is the ephemeral degradación of a resource as surrounding condicións become unable to hold the resource in place reliably. A resource's niche of operación becomes increasingly small, in essence 'drying up' and disappearing.

Sublimación is a challenge seen in nearly all occupacións, although as disciplines age and are aided by shared research and commonly agreed-upon language, spaces capable of upholding shared resources are expanded, so as to increase the resources' endurance in human mind-space; making all necessary resources more reliable. As examples;

• Legal code can be read many hundreds of years since publicación, and hold nearly the original meaning in the minds of readers; humans' minds are comparable, and many people can closely imagine scenarios applicable to the original authors. In essence, learning of the human condicións of millenia ago help us in a process of emulación; bringing sense back to logics described in archaic languages.

• Engineering and architecture diagrams are a medium capable of being read globally and across language barriers, because of a common base comprehension of maths and number theories.

Curiously, a similarly-dangerous process of sublimación is in process annually, in the biological domain of agriculture. Original seed germs are increasingly being replaced by synthesized clones; the niches germane to breeding of original-seed crops are shrinking - again using popular phrasing, causing populations of organic crops to 'dry up'.

Such sublimación is much more a problem in machine coding disciplines than in similar occupacións, supposedly because the discipline's young economic age causes commercial cycles of hyper-adopción and reckless abandonment, recognizable to any guardians or cleaners of small childrens' playrooms.

Popular incomprehension among consumers leads to dangerous presumpcións around duración, price, and energy use of onscreen experiences, leading to reckless abandonment of the precious machines used to express them, and disregard for the enormous burden of coordinación essenciál in their producción.

Much more could be said around themes comparing machine coding to numerous human occupacións and hobbies - from meal preparación to consumer producción to the embroidery of images. Our company, in the course of incorporación, is able to comprehend the landscape more clearly by relying on lenses of biology and language; in essence, considering the biographies of popular programs as they progress an inescapable course from birth to death; composición to erasure.

Operand makes open-source adopción simpler.

Large global corporacións keep commercial dominance by means of closing borders; users of Gmail bound to be users of Google Drive, and similarly does Outlook encourage use of Office 360. Rarely are users encouraged or enabled to explore the expanding number of equally usable, though usually more disconnected, open source replacements made and published under no regard for commercialización.

An organizing body is necessary to encourage consumers to choose open source programs; these programs can be made more secure than many closed-source, corporación-beholden codebases, so a moral obligación demands our company to make public-domain programs equally as appealing as the more popular choices in use globally today.

Our iniciál plan for encouraging adopción includes code-based and machine-based approaches.

Approach A: Ensure reliable open-source codebases.

Many open-source coders are unpaid and challenged to manage a barrage of issues each day, raised by users of their code across the globe; rarely do such producers see income in response.

Operand seeks to channel resources to the managers of key codebases, chosen on a basis of resiliency and endurance, as a means of ensuring decades of operación for many necessary programs. Using sponsorships and cash prizes as primary means of encouragment can help align coders' energy to the needs of public-domain users.

Our company's operación leads are commissioned to sponsor public-good open-source missions. Of 9 possible, some likely ones are already chosen:

• Produce NixOS and Nix-language bindings across more accessible programming languages.
• Upgrade common legacy PHP programs, including WordPress, MediaWiki, and Joomla, by plugging in their popular database schemas to more modern application layers.
• Ensure Graphene OS becomes reliable on many mobile machines.
• Ensure Mobile NixOS becomes reliable on many mobile machines.
• Encourage adopción of open-source discussion boards, code and graphic design producción programs, passcode managers, and graphic design programs.
• Encourage use of the Gleam language as a general-purpose any-machine applicación base.

Addiciónally, produccións such as code readings and appraisals can help encourage educación around secure coding approaches, and express the need to keep the public resource of necessary code held by the shared commons.

Approach B: Share program access on deployed machine banks.

Learning to change the programs one uses can be enough of a challenge, disregarding the burden of operación for many open-source programs.

As businesses begin to consider dropping their dependencies on incumbent and dangerously opaque programs, Operand remains ready to shoulder the burden of managing shared resources.

In place of the common game plan among cloud companies - leasing colocación space in enormous buildings - Operand plans to mobilize in order to chase demand.

Our company's conneccións among companies like Ascxnd promise unique deployments of small, cloud-like modular boxes; in essence, repurposed shipping containers made up as modular processing blocks.

Such processing rigs can be placed on a trailer and hauled, to be plugged in as response to numerous supposed demands; including the needs of construction companies or emergency responders.

In addición to mobile lab builds, our company plans to enable libraries, schools, and small businesses to keep smaller business-essenciál deployments running in-house.

Share summaries

Our company shares are designed to be co-held by our employees; only employee shareholders are able to earn a salary.

Sponsors each help decide on deployments of company-managed gear.