you're arguing a position which indicates you don't know git's physical (textual) commmit structure.

Spend some quality time with:

    git cat-file -p HEAD

    tree ff1234...
    parent ccddef...

    fix(BUG-1245): my ai fixed it

    file efef12... Makefile
    tree a1b2c3... src/
    file f0ea12... README.md

Your homework is to go run:

    time (
      git ls-files | xargs -n 1 sha256sum
    ) | sha256sum

Your INSTINCT isn't wrong, your mechanics run counter to the practicalities of how git is designed to work, and the practicalities of the crucial defense that git-core is trying to divert: the ability to arbitrarily alter the signed(!!!) past, signed by third parties, with $ELDRITCH_SHA1 attacks.

You _still_ have to trust that GitHub.com or kernel.org won't get popped and start erroneously serving "signed but faulty" files and trees, but the urgency of moving to sha256 is about preventing faulty commits in the first place, which removes the requirement of "trust me bro!" relationship with the serving provider (or MITM).

The attack is I pre-author `Makefile => foo: echo "hello"; bar: echo "world"` along with `Makefile => foo: echo "hello"; bar: rm -rf / ; /* $ELDRITCH_SHA1_SPIRITS_GO_HERE */` that both hash to `ff1234...`

I then prepopulate the repo with `echo "hello"`, wait 6-9 months, then submit a commit for `echo "hello" ; echo "world"` and keep (in my back pocket) the alternate implementation that also includes $ELDRITCH_SPIRITS to force a collision and MY predetermined change in functionality.

I then have free choice as to whether I serve them "hello world" or "hello && rm -rf", and THAT's the plausible problem to avoid: the ability to "cloak" content anywhere within the repo if you have enough $ELDRITCH_SPIRITS and GPU's.

You have _really_ good points, but are woefully confused. The proper answer is (would have been) to include `tree ff12354...` along with `tree-sha256 abc123456789...` for another 20 years along with a `[git.hash_strictness]: default/lazy/strict`, and some oddball `git-rerere` type packfile extension which lets you map `sha1:ff1234... => sha256:abc123456789...` "transparently" rather than the horrific situation you're laying out (correctly!) that forks the ecosystem in to "longhash" and "shorthash" when most repos don't even care in the end.

1: https://swagger.io/docs/specification/v3_0/adding-examples/

2: https://en.wikipedia.org/wiki/HATEOAS

3: https://jsonapi.org

4: https://xkcd.com/927/

...obviously never productionized.

My responses came from a place of emotion, because there's something about them that is so striking, the odd perspective (or lack), the solid "non-blur" of a background, the juxtaposition of subject and method... when you stack all that together it's something special, and "selling" (or more precisely: letting people buy/vote with their money) is one way to encourage more of what you're doing.

Seriously, do your one of three artists proofs for some of these and shop around a gallery showing with SFAC or SF City Hall, then sell your "works exhibited to the public with certificate of authenticity and 10% of sale price going to SF muni"

They're just too striking not to get more eyes on them! Even if you don't, hopefully you feel the little warm glow of having climbed this mountain!

...and I'll be surprised if I don't see these pictures hanging in a bank/startup lobby at some point!

Then break plain language requests into tool-calling-ish shared functions [atHome(), isHoliday(), comfyTemp(), ...] and basically throw "linker errors" if a concept didn't have a definition, eg: "ERROR: concept 'comfortable temperature' not defined..."

...and yes: be able to highlight overlaps or conflicting instructions at the semantic layer... those being less important than conflicts at the safety/invariant layer.

The idea was to have a bunch of basically "is_comfy_temp.prompt" => "is_comfy_temp.lisp" and be able to right click on any of the prompts and "show source" to understand, debug, simulate, validate, etc.

As you get real trials you end up with a foundational "StdLib" of at least necessary concepts although yours and mine might contain different data/preferences. And being able to edit "comfyTemp()" in one place as opposed to spread out in a bunch of different home automations (eg: isSummer vs isWinter else also: ifHumidity && upcomingWeather || realtimeElectricRates, etc...)

Mode switching has a cost. Usually std::sort is good enough compared to picking the prime optimal algorithm for your expected shape. Just call the function and get on with your day.

Invariants were like "if outside temp < 40 or inside temp < 65: heater.minTemp( 65 )"

Axioms were like: "if {we're home} and it's {not a holiday} the house should be {comfortable temperature}".prompt

...and then that would get decomposed and translated into interlocking code for the scene(s). I'll have to look at this language a little more closely with those kinds of constraints in mind!

You're kindof translating `*.prompt` to either prolog (yucky!), lisp, lua, or javascript (for inspectability/debuggability), but this whole bend thing might be an exact fit for the problem space! Limited set of objects and states, bounded set of "invariants" (laws), and layering on top the general state modification activities (either "evaluated every 5 minutes and reconciled" or "set the scene xyz...").

https://en.wikipedia.org/wiki/Bookbinding#text-block

Cover => recto/verso => Endleaf => Textblock{ signatures... } => ...then back to endleaf + cover like a sandwich.

I started with cereal boxes and old wrapping paper and have graduated to fancier wrapping paper and bookbinding board (stiffer, like matte-board).

The great benefit of doing something like this is being able to glue one of those cool ribbons into the spine for use as a bookmark!

https://en.wikipedia.org/wiki/Meet_the_Natives:_USA

https://www.youtube.com/playlist?list=PLfovX-ia33tF-6W_gfTvL...

...basically this is the "take a few near-pre-contact villagers around the U.S. and show them how cool the rest of the world is" that the article talks about.

There was another show (might have been "Going Tribal(?)") which did the reverse, where a "modern man" tried to integrate into daily life tribal life, eg: setting fish traps, mauling taro root, trying not to scare away rabbits while hunting with bows and slings, etc.

...and that was a grand improvement over having to make a "tic-tac-toe" table where you'd be putting things in the particular surrounding cells to fake these fancy border-types.

I'd like to know at a glance if I'm using the right "MacBook TB4 Monitor Cable" (or "guaranteed high-ish wattage") as opposed to "random usb-c which may/may-not work".

I went through my "sentimental" 3.5" floppy spelunking era, basically a bunch of `rsync /mnt/floppy ./floppies/xyz-whatever` and pushed that to my remote server backups... ahh, the joys of finding my old CS1301 homework with "SSN: xxx-xx-xxxx" in the README.txt (or header comment)... good times!

I've already bought a USB-Floppy (and other USB-based "old media" bits), but I'll definitely be keeping the LS-120 now as I think IDE is more durable (and IIRC LS-120 drives were more "precise" w.r.t. track recovery/locating since they supported the higher data densities). Doing some searches show there's also "IDE-to-USB-C Adapter Kits(!!!)" which will definitely be going into the bucket too!

"Ring ring! Hello? Hey Siri, what's the weather and call my ex so I can hang up on them!"