agambrahma

Found some insightful bits within this in a general 'principle/discipline of programming' sense, since it's written by an "outsider" yet in the presence of "the OGs"

E.g.

> The task of writing a program ... is traditionally characterized by a specific set of disciplines.

> In essence, the programmer must define some sort of algorithm which will accomplish the objective, then map that algorithm onto the available resources of the computer using a specific set of tools — the programming language.

> Conversion of an idea from its conceptual form into its coded form involves the acceptance of *nearly brutal language restrictions* which result in strict formalization of the process.

> The programmer starts with an idea of WHAT he wants the system to do, then spends hours or months describing HOW it should be done.

> The generally-accepted complexity of this task has spawned some rather elaborate disciplines which reduce the probability of error.

I think the fact that LLMs are "eating up" so much of software development is that software development itself never properly matured. It remained in this form for decades longer than it should've (for various reasons)

Really like this, will get one

One annoyance that I anticipate though: can we have a "separate identity" for these 'home devices' ?

[note: this is not a concern if you live alone]

I.e. when used in a family environment, you have to pick one person's identity as the 'main' identity ... but we'd rather have a 'home' person with whom we share stuff, whom we add on calendars etc, and then view THAT info on the home devices.

This sidesteps the whole "WHOSE calendar/reminders are showing" issue.

This is a problem on the homepod, and will only be exacerbated on the HomeView.

Or ... how do other folks solve this?

Yeah, the content + feel felt like I'm reading this in 2013.

Nothing wrong with that, it's a good thing that stuff is discovered anew [as opposed to being lost/forgotten], but it did bring a smile to me.

Yes, that's the right idea.

It's less about browsers, and more about server/edge/local-agent runtimes.

Wasm lets you have

- sandboxing (untrusted actor code)

- clean snapshot/restore

- portability of actor across machines

If you don’t need those properties, then yes ... native is obviously the better choice

Yes, simply for local inference -- not much, native is the obvious choice.

The value would be in actor processes, where you can delegate inference without paying the 'copy tax' for crossing the sandbox boundary.

So, less "inference engine" and more "Tmux for AI agents"

Think pausing, moving, resuming, swapping model backend.

I scoped the post to memory architecture, since it was the least obvious part ... will follow up with one about the actor model aspect.

Agree, maybe "changes the physics" was too strong, shared cpu/gpu memory is not new.

What is different then is the combination of

1. UMA memory (and yes, iGPU had this, pre-M1) 2. enough bandwidth / GPU throughput for local inference 3. straightforward `makeBuffer(bytesNoCopy:)` path

So, the novelty isn't the shared memory itself, but the whole chain lining up to make the Wasm linear memory -> Metal-buffer approach practical + performant enough.

(and not saying there's some Apple Silicon magic here either ... it'd work anywhere there was UMA and no-copy host-pointer path)

This is crazy impressive ... the kind of thing that should inspire one to do more, much more, than whatever "mere plumbing" one happens to be doing at the moment

Tried mobile app, mobile website, desktop website

Cannot place an order to ship (!)

Applied plasma physics (spheromaks, solitons, field topology) to UAP observations. Explains the "five observables" better than the spacecraft model ... though radar signatures and energy density remain problematic (!)

Speculative but grounded in real physics (I used ChatGPT/Gemini as thinking partners, then verified claims)