Also: wouldn't it be great to have an "advanced" timeline customizer, eg: lambda-ish functions? (this I didn't bother sending to y'all...)

I've generally got mine wired to `Calender(15m) => Weather(5m) => Calendar(15m) => MotivationalQuote(5m) => Calendar(15m) => ...etc...`, but that's extremely gross (as you can imagine) with a bunch of `Calendar (copy) (copy) ...` because I can't be bothered to spend time fixing it up.

Thinking it through, I'd kindof like "primary queue (15m)" vs "secondary queue(5m)" and have "the algorithm" automatically merge them at runtime (ie: two pointer heads as you alternate queues), but the end game is effectively:

    def next_card(handle):
        if handle.time.hour == "12:00":
            return ( "Lunch Break", "30m" )
        elif handle.time % 60 == 0:
            return ( "Calendar", "15m" )
        else:
            return ( handle.plugins.shuffle()[0], "5m" )
        ...etc...

Specifically for your example of maps, I would stick mostly to border buttons or UDLR gestures to "page" around rather than than trying to show a smoothly refreshing drag area.

Since you can _see_ the screen refreshing/drawing, and assuming you're using +/- buttons instead of "pinch to zoom", try drawing animations "in layers", ie: spend 100-300ms slapping "zoom tunnel boxes" trying to keep the user oriented while interacting.

Break the tiles into "thick => thin => letters => detail" and wait for them to quiesce before stacking more layers.

Rule #1 of optimization, you can never do something faster, you can only "do less"!

Rule #2 of optimization (amdahls law?)- optimize the slowest parts before you optimize the faster parts (and there's a limit to each!).

...from an end-user perspective, I would love if you respected my time and concentration when doing something "interactive".

Imagine scrolling through an e-ink address book. Imagine you spam only the (properly placed / laid out) first letter of first name and first letter of last name, and then after ~500ms of no movement, only THEN write out the remaining letters, phone numbers, icons, etc.

For e-ink interactive: every (slow, expensive) pixel that you write that gets scrolled off the screen is wasted time.

#1 - do less. In interactive cases, draw less pixels.

#2 - keep context. Use proxies/wireframes, "first letters", and "bold strokes".

#3 - fill in layers. Think "iterative Mona Lisa" and "progressive jpeg"

#4 - actually being slower is okay if you end up "feeling faster" or "seeming cooler"

Lean in to the defects and quirks of e-ink, make them feel intentional rather than trying to duplicate 60fps 16M colors.

They talk about "living at the bottom of the well" within our solar system (gravity well, that is). Mars effectively "divorces" from Earth (no kings / 1776, plus they need to be 100% self-sufficient), casually called "Dusters" presumably due to the Martian dust.

People working on the asteroid-based bases (in our "Asteroid Belt") are called "Belters".

Then also read: "The Moon is a Harsh Mistress" by Heinlein, where humanity colonizes "Luna" and have "Loonies" for relatively obvious reasons.

Both books delve a bit into the physiological changes but also the socio-political ramifications of humanity in space, and both are _excellent_ reads!

    $ echo '{ "Hello": "World" }' | tson --parse
    ERROR: ...refusing to interoperate w/ JSON b/c we want to be different

    $ echo '{ "Hello": !number 3.14 }' | jq '.'
    jq: parse error: Invalid numeric literal at line 1, column 19

I've been explicitly trying to support `--json5` on some of my internal work tooling. Being very explicit that I'm not parsing `--json`, but instead using a slower (but more forgiving) `--json5` which would allow comments, trailing commas, whatever JSON5 claims to support.

This `--tson` feels like it's solving two problems in disguise:

1) It wants to be `--json6` (eg: `pi: !number 3.14`)

2) It wants to use it's own `--json6` (aka: `--tson`) to write "json-ish schemas" (eg: `foo: [text; 1..10]` for presumably a list of maximum of 10 elements?)

...JSON was a blessing because it existed naturally as an unambiguous "lists, dicts, values" representation that most programming languages treat as first-class citizens. Missing "sets" and things like "date" or "boolean" are certainly under-specified, but that's the real-world impact of JSON as lowest common denominator.

SCHEMA's don't have nearly as much natural, unambiguous representations across many programming languages. The closest thing I can think of is straight up Java + Constructors (ie: a full programming language for object initialization but w/o allowing interaction or behavior).

   CalendarEvent x = new CalendarEvent( Date start, Date end, Boolean all_day, List>, ...etc... )

Where it starts to get annoying is "door open" and "motion detected" triggers. Motion detected can be played off as a sloppiness in the sensor cone, but going from "instant" to "laggy video game" when you have a physical trigger can be relatively annoying.

Personally, I tend to have a `source ./source-me-auth` which does stuff like `DB_PASSWORD="$( pass show blah.com | head -1 )"`, but that still means I end up with secrets dangling around in my environment. The "source-me" file is safe to share, but my runtime environment is tainted (for good and bad...).

I saw something w.r.t. the way open-claw handles things where you basically say `export DB_PASSWORD="REDACTED@SECRET_001"` and then it basically outbound filters network requests to hydrate that with `s/REDACTED@SECRET_001/$REAL_SECRET/g`, and I _really_ like that mechanism b/c it defers secret usage to runtime and keeps it physically "out" of the application itself.

Basically, having `with $SECRETS -- some_app.sh --some params ...` wouldn't be terrible (conceptually).

I never watched much anime, but an old college roommate put me through Neon Genesis Evangelion and it holds a special place in my heart. :-)

    /def new_.*(/s+8
    /2026-/e
    /except/+1;/raise

    /x/e-3
    /x/+1
    /x/;/yz

I absolutely hated brushing the iWatch screen and triggering random crap and there was no other way to interact with it! Garmin's w/ 5 buttons and transflective (sunlight-readable) displays have been the closest alternative, and they have a pretty cool "touch-screen alt mode" which you can access via press+hold on two of the diagonal buttons to enable/disable (or automatically starts if you open up the "maps" app for dragging it around).

Long battery, sunlight readable, buttons.

https://www.youtube.com/watch?v=0lwpS5M7hgA

"""AI Overview: No, the Asus ROG Ally is not actually an Xbox. It is a handheld Windows computer made by Asus, even though it features Xbox branding and uses an Xbox-style controller layout"""

http://www.catb.org/~esr/writings/taoup/html/end-user.html

"""Master Foo turned to the end-user. “Tell me”, he inquired, “why do you seek the Way?”

“I am discontent with the software I see around me”, the end user replied. “It neither performs reliably nor pleases the eye and hand. Having heard that the Unix way, though difficult, is superior, I seek to cast aside all snares and delusions”."""

AI + Prompting can get you there, but it's still fairly laggy. Honestly, VSCode (aka: Cursor) w/ the vim plugin, and `F2-rename` has been the sweet spot for me. Reviewing diffs with `git diff | view -` and browsing them with vim is another useful.

:wq