Maybe I’m dreaming.. but a stealthy trend of distorted words is afoot. Is that an ai defense/poisoning mechanism, innocuous misspellings/truncations or artifacts in generated content?

Wehn you tinhk auobt it, hnumas inrtrpeet glphys saliyombllcy and can raed wodrs eevn when deitsortd. I might be following too many feeds..

You can never be too sure anymore..

$ git remote -v
all             cgit@thedroneely.com:thedroneely/dotfiles (fetch)
all             git@codeberg.org:tdro/dotfiles.git        (push)
all             git@github.com:tdro/dotfiles.git          (push)
all             cgit@thedroneely.com:thedroneely/dotfiles (push)
all             git@gitlab.com:tdro/dotfiles.git          (push)
codeberg.org    git@codeberg.org:tdro/dotfiles.git        (fetch)
codeberg.org    git@codeberg.org:tdro/dotfiles.git        (push)
github.com      git@github.com:tdro/dotfiles.git          (fetch)
github.com      git@github.com:tdro/dotfiles.git          (push)
gitlab.com      git@gitlab.com:tdro/dotfiles.git          (fetch)
gitlab.com      git@gitlab.com:tdro/dotfiles.git          (push)
thedroneely.com cgit@thedroneely.com:thedroneely/dotfiles (fetch)
thedroneely.com cgit@thedroneely.com:thedroneely/dotfiles (push)

Basically setup the configuration in the right place, find the extension id from the Chrome web store URL and run chromexup.

[main]
branding           = chromium
remove_orphans     = True
parallel_downloads = 4

[extensions]
BlankNewTabPage   = jaadjnlkjnhohljficgoddcjmndjfdmi
JavaScriptToggle  = cdcgbgnfhhdmdkallfmlachogpghifgf
NoHistory         = ljamgkbcojbnmcaonjokopmcblmmpfch

Side note: NoHistory is good for disabling history (Firefox has options). If the history/bookmarks database gets too large, funky auto–suggestion stuff can happen (100% processor usage). imo, it’s best not to trust browsers storing bookmarks anyway and use an independent tool/method. The less data coupled to browsers the better — at least if you’re like me and swap browsers regularly.

So, I’ve been thinking (uh-oh).. there’s this idea/law by Melvin Conway (popular in programming books) that goes something like this;

Any organization that designs a system will produce a design whose structure is a copy of the organization’s communication structure.

Many suns ago, local events “piqued” my curiosity into cryptocurrency hype. Praise be to the king–no really! Anyway, reading the leaves and decrypting the crypto–babble made bits of sense.. at least superficially.

The point: there’s plausibility that one or many powerful democratic government(s) designed/orchestrated the cryptocurrency ecosystem. Yes, hard to prove but.. the architecture is an uncanny 1:1 copy of government communication. Even abuse/failure modes are 1:1 (see sybil, a 51% attack: similar to democracy’s extra fun “limbo” mode).

..if it wasn’t for this guy visiting my country. I am now “enlightened”. Spoiler: Blockchain computationally formalizes/describes a government’s high power restraints within democracy. In civics (social studies), democracy is decentralized power (no/many kings) and therefore implicitly inefficient.

Democratic governments (in perfect world) communicate/act/bank;

1. In public (freedom of information)
2. With immutability (no deleting things)
3. With consensus (majority vote)
4. With inefficiency (to weaken bad actors)

Citizens and other low power (centralized) entities can do some of the above (federation), but mostly (wisely) communicate/act/bank;

5. In private (freedom of association)
6. With mutability (to protect privacy)
7. Without consensus (freedom of expression)
8. With efficiency (to build–up fast actors)

Individually, (5-8 > 1-4) no? But (1-4 > 5-8) in dictatorships (5-8)? Blockchain governments for maximal oversight? Not happening :)

When making hugo themes, it’s probably better defaulting to absURL and relURL over baseURL for links. It avoids most breakage on links that depend on a base and more easily allows multilingual support with absLangURL.

However realistically (for anything), interpretations of file, directory/, absoluteness, and relativity are varied. Testing artifacts for ≈ 100% internal/self linking consistency, under different conditions, and after every code change is better time spent debugging. Sub directories are exceptional cases.. even now some of my links are broken except that my web server automatically fixes common mistakes (:

Different words similar meaning? --references is NixOS speak for direct package dependencies. --requisites list all. These work with the nix-store command.

$ readlink --canonicalize "$(type -P which)"
/nix/store/r78jv9xgxnvsm5vpasf5ldkc28pkri6r-which-2.21/bin/which

$ nix-store --query --references /nix/store/r78jv9xgxnvsm5vpasf5ldkc28pkri6r-which-2.21
/nix/store/4nlgxhb09sdr51nc9hdm8az5b08vzkgx-glibc-2.35-163

which directly depends on glibc. Swap --references to --referrers for paths pointing to which.

On Guix, list/draw dependencies with guix graph.

guix graph --type=references which

So, I just realized that infinite scrolling is a two birds, one stone kinda thing. Basically; your servers do almost nothing, while the clients toil your complexity (and their time) on the server’s behalf.

It’s a bad all–you–can–eat buffet in computer algorithmic form. The rewards? Architectural flexibility + implicit user retention. I recently saw someone scrolling a YouTube channel all the way to the end just to find the first video. That’s the server’s job.. and a lot of wasted user time.

I came across a good article on finding video feed links from various (mostly western) sites. Odysee links have a funky format that are prefixed with https://odysee.com/$/rss + channel.

So this (channel):
https://odysee.com/@andkos.music:1

Becomes this (feed):
https://odysee.com/$/rss/@andkos.music:1

Here’s my new AI assistant.