For some reason this makes me think of a Roomba trying to escape a living room. Contrast to the stories of captive octopus escaping their tanks...
1,893 karma · joined May 11, 2010
Basically a 1992 rogue-lite where each room is a different solitaire game. eg: front parlor == clock solitaire, first bedroom == regular solitaire, upstairs is blocked by freecell, etc...
Screenshots: https://www.mobygames.com/game/1986/solitaires-journey/scree...
It's a fairly rich concept, you have a ton of different gameplay bound together by a very loose plot/quest mechanisms (eg: blue key == blue door ; boss == win 2 games of solitaire).
Definitely worth sharing if you've got some solitaire fans in your life!
"Open Source Muti-Machine": The heavy, ultra-stiff mass of the cast iron dampens vibrations and forces the cutting tool to move in a perfectly straight, micron-accurate line dictated by the factory-bored cylinders.
Ask an AI about it, but conceptually it's an amazing concept. There are probably billions of "nearly micron-accurate" machines, and if you're 1000% repeatable 90° then the world is (eventually) your oyster.
Price per acre could suss out whether it's developed or in demand vs more rural (less price per acre).
Other than that, bravo! Great idea, well implemented!
Cheaters (athletes) are always incentivized to cheat in "new and exciting ways" today. It's impossible to defend against all possible new forms of cheating, but they instead keep blood samples for up to ten years so that "when they figure out what to test for", they can retroactively penalize participants.
Same with online cheating, save high fidelity recordings and be able to replay. As detection catches up to exploitation, you ban hammer the prior exploiters.
I have ones for cooking oil, olive oil, chili oil, and sesame oil... the chili and sesame in easy-to-use, flavorant amounts are great to dash into vegetables or a salad or whatever, and having it atomized instead of drizzled makes it so much better and more convenient!
Everything the post mentions is 100% true and well-reasoned, especially with the inclusion of pledge/chroot/etc. for dropping privileges.
There's two diametrically opposed deployment mechanisms:
1) stack towers of glop on top of each other until you're running a simple `echo "hello world"` on top of a docker container inside a vm in a proxmox server as part of a k8s cluster under a hypervisor running on remote compute...
2) just run `bash -c 'echo "hello world"'` and front it with CGI (stateless, single binary, yada yada yada...)
Take a peek at https://github.com/Domain/bash.cgi ... not that i'm suggesting that 'bash over busybox using cgi-bin' is the "proper architecture", it's more trying to illustrate that the amount of code that holds you back from being nearly truly "frameworkless" is tiny and easy to reason about.
For some of the internal tooling I'm doing for work, I've been tending towards:
some-cmd [--json|--markdown] ...yet-more-args...
I'm poking (lightly) at the locallama game, have a fancy MBP5 with gobs of ram (so I can demo/trial locally) and have been semi-waffling between whether to chase a mini or studio for local "always on" type stuff.
My outcome was "CapEx v. OpEx", and dropping another $5k for an aluminum cube buys a lot of OpEx (eg: just trickle-drip HF/OpenAI credits to a raspberry pi or VPS orchestrator rather than trying to do the inference locally), ie: $5/mo inference for 1000 months.
HOWEVER, there's definitely a role for that 1-10 TPS type "ambient inference" that I wouldn't mind sustaining on any sort of always-on / local / private compute. My main email address is still on ...@yahoo.com and their spam filtering has gone to absolute shit.
Being able to have the always-on mini (local, trusted, no private data leaves my control) poke at the IMAP/email and thresh it into SPAM/HAM/Personal/Political ... random spot check, I'm getting ~5 emails per hour, and that's completely tractable for staged low-med-high processing. (Subject + rules.py? Subject + Body + LocalSlowTPS? Subject + Body + LocalDeepTPS? Subject + Body + RemoteLLM?)
Even if you did 10000tps of "jev" that's an incredible value... not quite "Literal AI Packet Router", but as you're dancing aroud saying... "Speed is a Weapon"
Look into "OODA Loop" => """The OODA loop is a four-step decision-making model—Observe, Orient, Decide, Act—created by U.S. Air Force Colonel John Boyd to help leaders make fast and accurate choices in chaotic situations. // The main goal is to cycle through the loop faster than an opponent or changing environment. By operating inside another person's loop, you create confusion and outpace their ability to respond. While initially designed for aerial combat, it is now widely used in business, sports, and crisis management."""
But you're right in sense: moderate intelligence at superhuman rates (and presuming moderate energy usage) is very compelling compared to an intelligence that takes 1000 years to return "42"
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/
...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".