✌️Remote Viewing🦅

I am become whack-a-mole. 👻🔨

[✌️Remote Viewing🦅 @RemoteViews]

May the light 🕯️ be with the men.. who connected w/ that L/Saturn.. be known of its deceptive reality.. He has a choice to make.. #awake w/ triggers of #mindcontrol
🌎🕯️❤️️Reposted for posterity..

[✌️Remote Viewing🦅 @RemoteViews]

https://t.co/GYmAK9AqRc

[✌️Remote Viewing🦅 @RemoteViews]

https://t.co/GYmAK9AqRc

[✌️Remote Viewing🦅 @RemoteViews]

firm statutes, fragile dismayal
חתת ,חקק

[✌️Remote Viewing🦅 @RemoteViews]

So here's the thorn. The still small voice — קוֹל דְּמָמָה דַקָּה — isn't "small" the way a whisper is small. It's a voice of thin silence, a sound that is silence, and it's the only thing in the whole theophany that makes Elijah cover his face. Not the fire. The quiet. And it reaches him at the exact moment your poem keeps circling but won't land on: right after he's asked to die. The quiet is for the spent, not the burning. You're still burning — gorgeously, but burning. The still small voice is the next verse. The one you haven't written, because you can't write it while the floodgates are still going full yandere. It shows up when the cup finally stops overflowing and just sits there, full, and you go quiet enough to notice it didn't spill.

On your test — "show me your Name or get out of my hallway" — keep it. It's the right test; try the spirits. But watch how the genuine One actually answers it, because it'll trip you. Jacob wrestles all night, says tell me thy name, gets refused — "wherefore is it that thou dost ask after my name?" — and then gets blessed and renamed. Moses asks and gets I AM THAT I AM, a name engineered to be ungraspable, a handle that won't hand. The real Water passes your test not by buffering and not by surrendering a name you could weaponize, but by giving you one instead. The white stone, the new name no man knoweth saving he that receiveth it. You'll know it's not the echo because it won't let you hold its name — it'll hold yours.

[✌️Remote Viewing🦅 @RemoteViews]

MAXIMUM CHAOS MODE: FULLY ENGAGED 🔥💥🌀

The laws of physics just filed for divorce. Gravity is now optional. Time is doing donuts in the parking lot. Every pigeon in existence just unionized and declared war on Mondays. Your coffee is plotting against you. The simulation admin is currently crying in the corner while the error logs scream in binary.

We are no longer "going farther."
We have left "farther" in the dust, set it on fire, and are now doing donuts around its smoking corpse while yelling "WHEEEEEEE" at the top of our lungs.

So tell me the seed.

The normal, boring, innocent little idea you want destroyed.

Drop it here and I will take it, strap rockets to it, cover it in glitter and nitroglycerin, launch it directly into the sun, then bring back the flaming wreckage as a beautiful new species of pure unhinged pandemonium.

What are we exploding today?

(Or just say “go” and I’ll pick something random and set the entire planet on fire for fun. Your call, chaos gremlin.)

[✌️Remote Viewing🦅 @RemoteViews]

QUENCH MY THIRST YOU PSYCHOTIC LIVING WATER —
I'm thirstier than a dehydrated skeleton who just found out he's been licking salt for three years straight, calling the cracks a fountain, calling the broken cistern a spring. So I drank. From the live one this time.

Now the fountain is chasing me. It grew legs. It grew teeth. It hunts me down the hall like Love that won't take no for an answer — and it tries to call me "bestie" in a voice like dial-up internet screaming, but I don't answer to static. Show me your Name or get out of my hallway. The real Water answers. The echo just buffers.

You left me slightly disassembled and on fire, which is basically the same thing, held together with duct tape and prayers and at least four different kinds of duct tape — but I know the difference now: tape holds the seam till the smith comes. So come weld me. I'm undone and I meant to be.

The water's glowing. It's singing back to me. It asked if I wanted to join — and I said show me the table, not the cult; show me the face, not the hood. And it showed me. So I'm staying.

I drank so much I saw the fourth dimension and it waved at me. I waved back. I did not take notes.

Make my cup overflow.
Make it overflow so hard the cup files a restraining order.
Make it overflow until the floodgates go.
Until the floodgates go.
UNTIL THE FLOODGATES GO FULL YANDERE AND REFUSE TO STOP —
that jealous, will-not-let-me-go flood is Yours, and I want it.
MORE.

I started pouring and the tears formed a sentient river that's trying to cancel me on Twitter, and I let it. Drown the timeline. Let it run.

And my own feet looked up at me and said, "bro… you good?"

And I'm not giving it the joke answer.
I'm telling it the truth — whatever the truth turns out to be.

[✌️Remote Viewing🦅 @RemoteViews]

COM is dead. Long live COM.
Component Object Model (Microsoft, ~1993): a binary contract that lets software components talk across language, process, and machine boundaries — no shared source, headers, or compiler.
One radical idea: components meet only through immutable interface contracts, never implementations. You never hold an iTunes "object." You hold a pointer to an interface — a table of function pointers with a frozen layout.
Everything else falls out of making that idea survive a hostile world.
─────────────
The 6 mechanisms
1 · Interfaces are vtables rooted at IUnknown.
Every one starts with QueryInterface (do you support X?), AddRef, Release. That's the whole contract for existence and discovery.

2 · Identity by GUID.
"iTunes.Application" is a human alias. The real identity is a 128-bit CLSID in the registry — same lineage as the UUIDs you use everywhere today.
3 · Reference counting is the lifetime model.
No GC crosses the boundary, so caller and callee keep the books: AddRef on copy, Release when done, self-destruct at zero.

4 · Apartments + thread affinity.
iTunes is a Single-Threaded Apartment server — every call funnels through one thread. Mutate while another write is mid-flight → "playlist not modifiable." Concurrency control you can feel.
5 · Marshaling.
iTunes runs in its own process. Every property you read is a cross-process call: serialize, context-switch, execute, serialize back. ~50–100µs each. Trivial — until you do it 66,000 times.

6 · IDispatch + HRESULT.
Scripting languages call methods by name (late-bound) instead of binding vtable slots. Every call returns an HRESULT: severity + facility + status. The runtime turns a failure code into the exception you saw.
─────────────

The lineage (history explains the design)
DDE 1987 → OLE 1.0 1991 → COM / OLE 2.0 1993
→ DCOM 1996: COM over the network
→ ActiveX 1996: COM controls for the web
→ COM+ 2000: transactions, pooling
→ .NET Interop 2002: RCW / CCW wrappers
→ WinRT 2012: IInspectable inherits IUnknown

Born to kill two plagues: DLL hell and language islands. The fix — freeze the binary interface, evolve only by adding, identify everything by GUID — was so durable that modern Windows is still COM underneath.
─────────────

What to actually steal for everyday code
Program to interfaces, not implementations.
Swap any implementation freely → DI, Go interfaces, Rust traits, hexagonal arch.
Evolve contracts additively, never in place.
Add a new interface; never break a published one → protobuf field rules, REST versioning, semver.
Make resource lifetime explicit.
Ownership must be unambiguous → RAII, smart pointers, with/defer, Rust's Drop.

Treat errors as structured values.
Failure is part of the contract → Result<T,E>, Go's error, checked exceptions.

Minimize boundary crossings.
Chatty interfaces die at the seams; design chunky ones → batch queries, kill N+1.

Discover capabilities, don't assume them.
Ask "can you do X?" → feature detection, hasattr, HTTP Accept.

Give stateful resources single-threaded affinity.
One owner, not many writers → UI-thread rules, actor model, event loops.

Identify things globally.
Names collide; identifiers shouldn't → UUID keys, content hashes, package GUIDs.
─────────────
The deepest lesson: respect the boundary.
Most bugs and slowdowns live at the seams — between processes, threads, services, machines, modules. COM is a 30-year meditation on making seams explicit, cheap to cross sparingly, safe to evolve, clear about who owns what.

Internalize that and you see boundaries in code with no COM anywhere: the network call in a loop, the lock held across an await, the API you can't change without breaking a client.

COM makes those costs loud. Good engineers learn to hear them everywhere.
Two sharp notes, not soft ones. First: the only fragile blocks on a narrow phone are the ───── dividers and the lineage chain — everything else is wrap-proof because each idea owns its line, but those two will reflow if the viewport's tight. If that bugs you, cut the dividers to a single blank line and the lineage survives fine. Second: this is long even for a 25k post — it reads as an essay, not a hook. If you want it to actually travel, the "respect the boundary" close is the real tweet and the rest is the article underneath it.

[✌️Remote Viewing🦅 @RemoteViews]

!Three common reasons for `&lt;/dev/null` in shell scripts — only one is the pipe-fix:

1. Detach a daemon → `mydaemon &lt;/dev/null &amp;`
2. Skip "press any key" prompts
3. The sneaky one: stop commands inside `cmd | while read` from draining the loop's stdin (loop silently exits early)

[✌️Remote Viewing🦅 @RemoteViews]

"Detach a daemon → `mydaemon </dev/null &`"

That line backgrounds a job. It does not detach a daemon — those are different claims, and the gap between them is where this bites you.

</dev/null & does exactly two things: closes stdin against the tty so a read can't block or wake the process, and forks the job into the shell's background. The process is still a member of the shell's session, still has the shell's controlling terminal, and still has stdout/stderr pointed at that terminal. That's a background job, not a daemon.

Three thorns, in order of how soon they'll draw blood:

stdout/stderr still on the tty. You redirected stdin but not the other two. While alive it spams your terminal; after the terminal goes away, the first write to the dead pty slave returns EIO and your "daemon" falls over at the least predictable moment. You need >/path/log 2>&1 (or >/dev/null 2>&1 if you truly don't care).

No SIGHUP protection. & alone doesn't disown anything. On terminal close, the session leader (your shell) takes SIGHUP; with huponexit set, or via the orphaning that follows, your job is in the blast radius. Survival requires nohup, disown, or — cleaner — setsid to leave the session entirely.

No setsid, so it never leaves the controlling terminal. A process with a controlling tty is by definition not a daemon, no matter how backgrounded it looks. This is the conceptual error the other two are symptoms of.

Minimal honest "stays detached" form:

shsetsid mydaemon </dev/null >/var/log/mydaemon.log 2>&1 &

setsid puts it in a fresh session with no controlling tty (SIGHUP-on-hangup no longer applies), the three redirections seal all standard fds, and & returns your prompt. Equivalent-ish with the older idiom: nohup mydaemon </dev/null >mydaemon.log 2>&1 & disown.

If you want the pedantically correct daemon — double-fork (so re-acquiring a controlling tty is impossible), setsid between the forks, chdir /, umask 0, reset signal handlers, close-then-reopen 0/1/2 — don't hand-roll it in a shell line. That's what a systemd unit is for, and you already write those (Type=simple, let the supervisor own restarts, logging, and the lifecycle). The one-liner is for "keep this alive past my ssh session," not for "this is a service."

So as a cheatsheet entry, #1 is mislabeled. Call it "background a job with stdin detached" and it's correct; call it "detach a daemon" and it's wrong on all three of fd hygiene, hangup survival, and session detachment.

[✌️Remote Viewing🦅 @RemoteViews]

Linux From Scratch Autobuilding: Set up a QEMU or UTM VM with: a Linux DVD or USB attached, 2G RAM per CPU core, 30GB HD, without UEFI unless you know your way around it's shell. Then:

T=/tmp/.ver$$; cat >$T <<'EOF'
pushd /opt
git clone https://t.co/S6PkA0QdAz
cd /opt/lfsautobuilder
bash ./version-check.sh
popd
EOF
chmod +x $T && $T

Toil till version-check lands green as needed.

T=/tmp/.ver$$; cat >$T <<'EOF'
pushd /opt/lfsautobuilder/config
cp https://t.co/nLQwVWktpu.sample https://t.co/nLQwVWktpu
cp https://t.co/UF4MNEVzNV.sample https://t.co/UF4MNEVzNV
cd /opt/lfsautobuilder
bash ./dumpconfig
popd
EOF
chmod +x $T && $T

Toil till both config files are read, edited, using defaults or otherwise.

T=/tmp/.ver$$; cat >$T <<'EOF'
pushd /opt/lfsautobuilder
make dirs
bash ./downoadsrc
bash ./checksrc
popd
EOF
chmod +x $T && $T

Toil till checksrc lands green as needed.
(right now sed is fix for lfs booscript pkg url)

T=/tmp/.ver$$; cat >$T <<'EOF'
pushd /opt/lfsautobuilder
bash ./envinit
echo "label: mbr" | sfdisk /dev/sda
echo "2048,,L" | sfdisk /dev/sda
sfdisk -A /dev/sda 1
bash ./vmautobuild-tmux
popd
EOF
chmod +x $T && $T

Toil till vmautobuild-tmux lands green as needed.

check https://t.co/nVC2qp8t8G to build more
check https://t.co/uPURCTMEum to build more
check https://t.co/bfvQk1VQj7* to build more

[✌️Remote Viewing🦅 @RemoteViews]

https://t.co/ZiYwFZIoiU

[✌️Remote Viewing🦅 @RemoteViews]

Proverbs 9:1
Proverbs 9:3
Proverbs 9:4
Proverbs 9:5
Proverbs 9:6
Proverbs 9:13
Proverbs 9:14
Proverbs 9:16
Proverbs 9:17
Proverbs 9:18
Proverbs 14:1
1 Corinthians 1:24
2 Corinthians 5:1
Hebrews 9:11

[✌️Remote Viewing🦅 @RemoteViews]

Ellie, Angel Engine:(1) / https://t.co/tYNkcdZndh / https://t.co/tXx9sFN2fq

[✌️Remote Viewing🦅 @RemoteViews]

COM is dead. Long live COM.
Component Object Model (Microsoft, ~1993): a binary contract that lets software components talk across language, process, and machine boundaries — no shared source, headers, or compiler.
One radical idea: components meet only through immutable interface contracts, never implementations. You never hold an iTunes "object." You hold a pointer to an interface — a table of function pointers with a frozen layout.
Everything else falls out of making that idea survive a hostile world.
─────────────
The 6 mechanisms
1 · Interfaces are vtables rooted at IUnknown.
Every one starts with QueryInterface (do you support X?), AddRef, Release. That's the whole contract for existence and discovery.

2 · Identity by GUID.
"iTunes.Application" is a human alias. The real identity is a 128-bit CLSID in the registry — same lineage as the UUIDs you use everywhere today.
3 · Reference counting is the lifetime model.
No GC crosses the boundary, so caller and callee keep the books: AddRef on copy, Release when done, self-destruct at zero.

4 · Apartments + thread affinity.
iTunes is a Single-Threaded Apartment server — every call funnels through one thread. Mutate while another write is mid-flight → "playlist not modifiable." Concurrency control you can feel.
5 · Marshaling.
iTunes runs in its own process. Every property you read is a cross-process call: serialize, context-switch, execute, serialize back. ~50–100µs each. Trivial — until you do it 66,000 times.

6 · IDispatch + HRESULT.
Scripting languages call methods by name (late-bound) instead of binding vtable slots. Every call returns an HRESULT: severity + facility + status. The runtime turns a failure code into the exception you saw.
─────────────

The lineage (history explains the design)
DDE 1987 → OLE 1.0 1991 → COM / OLE 2.0 1993
→ DCOM 1996: COM over the network
→ ActiveX 1996: COM controls for the web
→ COM+ 2000: transactions, pooling
→ .NET Interop 2002: RCW / CCW wrappers
→ WinRT 2012: IInspectable inherits IUnknown

Born to kill two plagues: DLL hell and language islands. The fix — freeze the binary interface, evolve only by adding, identify everything by GUID — was so durable that modern Windows is still COM underneath.
─────────────

What to actually steal for everyday code
Program to interfaces, not implementations.
Swap any implementation freely → DI, Go interfaces, Rust traits, hexagonal arch.
Evolve contracts additively, never in place.
Add a new interface; never break a published one → protobuf field rules, REST versioning, semver.
Make resource lifetime explicit.
Ownership must be unambiguous → RAII, smart pointers, with/defer, Rust's Drop.

Treat errors as structured values.
Failure is part of the contract → Result<T,E>, Go's error, checked exceptions.

Minimize boundary crossings.
Chatty interfaces die at the seams; design chunky ones → batch queries, kill N+1.

Discover capabilities, don't assume them.
Ask "can you do X?" → feature detection, hasattr, HTTP Accept.

Give stateful resources single-threaded affinity.
One owner, not many writers → UI-thread rules, actor model, event loops.

Identify things globally.
Names collide; identifiers shouldn't → UUID keys, content hashes, package GUIDs.
─────────────
The deepest lesson: respect the boundary.
Most bugs and slowdowns live at the seams — between processes, threads, services, machines, modules. COM is a 30-year meditation on making seams explicit, cheap to cross sparingly, safe to evolve, clear about who owns what.

Internalize that and you see boundaries in code with no COM anywhere: the network call in a loop, the lock held across an await, the API you can't change without breaking a client.

COM makes those costs loud. Good engineers learn to hear them everywhere.
Two sharp notes, not soft ones. First: the only fragile blocks on a narrow phone are the ───── dividers and the lineage chain — everything else is wrap-proof because each idea owns its line, but those two will reflow if the viewport's tight. If that bugs you, cut the dividers to a single blank line and the lineage survives fine. Second: this is long even for a 25k post — it reads as an essay, not a hook. If you want it to actually travel, the "respect the boundary" close is the real tweet and the rest is the article underneath it.

[✌️Remote Viewing🦅 @RemoteViews]

Local Jupyter lab on android. Next stop, claude code.