i chose to be left behind. new generations can continue with a.i. my time has come to move to something else. woodworking would be nice, japanese, the right way.

Elixir (Orthogonal ISA)

• Small verbs. Pure core. Effects as data.
• Programs are lists of instructions, not code that does IO.
• Adapters are the only ones allowed to “touch the world.”
• OTP keeps adapters in their lanes when they crash.
• Tests are fast because your core is pure.

• Is the core pure? If I run this function twice with the same input, do I always get the same output?
• Where’s the mess? Did I push database calls, logging, time, randomness, or IO to the edges (not hidden in the middle)?
• Is the state safe? Can my data ever end up in an impossible or nonsense shape?
• How do errors show up? Does the function clearly return success/failure instead of surprising me with crashes or hidden logs?
• Small Lego bricks? Can I explain this function in one simple sentence, and does it snap together cleanly with others?
• Replayable? If I record the inputs and events, can I replay them tomorrow and get the same results?
• Observable? If something breaks, can I see what happened without opening the code (through logs, IDs, or metrics)?

Practical checklist (pin to your monitor)

• No IO, Repo, DateTime.utc_now/0, System.*, :rand, send/2 inside core modules.
• Core returns data & results, never performs effects.
• Effects live in adapters that implement behaviours.
• GenServers delegate to a pure reducer.
• Tests for core are pure & blazing fast (property-based with StreamData).
• Seeds/clocks/UUIDs passed in.
• Data is plain structs; APIs are small & orthogonal.
• Errors are values ({:error, reason}), not raises.

Practical checklist (pin to your monitor)

• No IO, Repo, DateTime.utc_now/0, System.*, :rand, send/2 inside core modules.
• Core returns data & results, never performs effects.
• Effects live in adapters that implement behaviours.
• GenServers delegate to a pure reducer.
• Tests for core are pure & blazing fast (property-based with StreamData).
• Seeds/clocks/UUIDs passed in.
• Data is plain structs; APIs are small & orthogonal.
• Errors are values ({:error, reason}), not raises.

Paradigms & tools that map well

• Algebraic thinking: Make illegal states unrepresentable (structs + smart constructors).
• Pipelines & combinators: tiny fns that compose (then/2 helpers for {:ok, _} chains).
• State machines: encode states & allowed transitions (pure apply/2).
• Event calculus: “What happened?” not “What is.”
• Property-based testing: enforce invariants as properties.
• Data-first design: start from the data model; functions are transformations over it.

Where purity stops (and that’s okay)

• Talking to the outside world: DB, HTTP, filesystem, message buses.
• Real time: clocks, timers, Process.send_after.
• Randomness & IDs.
• Shared in-memory state (ETS, Agent) and processes themselves.

Core

• Does this function always give the same result if I give it the same input?
• Does this code avoid sneaky stuff like printing, saving to the database, or grabbing the current time/date?
• Is all the messy “real-world” work (saving, emailing, logging, randomness) pushed to the edges instead of mixed inside?
• If I swap out one outside service (like clock or database), is it easy?
• Can I test the main logic without starting the app or a database?

State & Processes

• If this piece holds state (like a GenServer), is the actual decision-making written as a simple “given state + input -> new state + output”?
• Are those “wrappers” around the state machine small and dumb?
• Is the state stored as a plain map/struct, not hidden in some global thing?
• Does time/timers only live at the outer layer, not buried inside?
• Can I play through a whole series of steps without spinning up actual processes?

Data Safety

• Can the data ever get into an “impossible” or “nonsense” shape?
• Are all the valid states clearly written down (e.g. status can only be new, paid, or canceled)?
• Do we check that lists/collections actually hold the right kind of stuff?
• When behavior depends on type of data, is it obvious and clean?
• Do we check important rules in one place, not scattered everywhere?

Handling Problems

• Do functions say clearly whether they worked or failed (no surprises)?
• Are exceptions rare and only used for truly unexpected crashes?
• Do we chain steps cleanly (not nested if/else jungles)?
• Are error reasons short and predictable, not random strings?
• Is logging only happening at the “edges” where we touch the real world?

Time, IDs, Randomness

• When we need “now” or “a new ID,” do we pass it in instead of grabbing it magically?
• Is randomness controlled so tests always run the same way?
• Do we get IDs through a helper, not straight from the system inside the core logic?
• Is time math always based on a value we pass in?
• Can we replay the same steps and always get the same result?

Events & History (if using events)

• Do we write down what happened (events) rather than jumping straight to side effects?
• Is state always rebuilt by replaying events?
• Are side effects (emails, saves) triggered after the events are decided?
• Are events stored in a clear, stable format?
• Can we rebuild everything just from the event history?

Dealing with Outside Systems

• For each outside thing (database, HTTP, file), do we have a small, clear adapter that just translates?
• Is there exactly one “real” adapter per outside thing in production?
• Do tests swap in fake adapters instead of calling the real thing?
• Do adapters turn weird system errors into simple, known errors?
• Are adapters skinny (no business rules in them)?

Small Lego Bricks

• Are most functions small enough to explain in one sentence?
• Can we snap them together like Lego pieces (pipe/compose)?
• Do we avoid doing real-world stuff in the middle of a pipeline?
• Do arguments and names line up in a consistent, predictable way?
• Could each function be described as a “command” over the data?

Testing

• Can we run core tests in milliseconds without a database?
• Do tests cover both “normal” cases and weird edge cases?
• Can we generate lots of random inputs to stress test the rules?
• Do tests assert both “good” and “bad” behavior?
• Can we simulate whole sequences of steps and still test them fast?

Observability

• Do we only log/measure things at the edges (not deep inside)?
• Do we carry IDs through so we can follow one request end-to-end?
• Can we see what went wrong without reading the code?
• Do metrics/logs talk in business words (“order failed”) not technical noise?
• Are logs structured (fields) instead of messy strings?

i recently encountered orthogonality ISA (instruction set architecture).

more about processor design but certainly applicable at software development.

i’ve been doing dummy adaptations of elixir modules and i’m loving it

the world indeed needs bad men to keep other bad men at the door. namely, it’s wiser to be a warrior who knows how to farm than a farmer who knows nothing about war.

doing functional programming feels so right.

i really don’t understand how people keep their distance from it.

it just feels right in my mind.

i have come to the conclusion that we crave someone ’cuz we lack something in the beginning — namely, authenticity and security.

yes, biology also dictates preserving the species, but since we are highly conscious beings, we can overcome that.

the more i heal, the less interest i feel in having - or being part of - a relationship with another human being.

i feel authentic and secure, and the craving is gone.

To oneself, love.

this is a simple test for github actions to publish this as a post.

jesus i lost count of how many commits until it worked.

we went old school. I did CMS quite simple and to my needs.

I’m doing microblogging from my phone and github issues.

how cool is that?

special since issues is the perfect word for each posts jiggles

I find myself studying physics again, reading new TOEs and so on.

Fascinating.

On the other hand, the only bad thing about moving away from modern civilization is the idiots. I’m gonna miss them so much.

But soon after they’re gone, I’ll be reunited with them and have interdimensional adventures across the whole Cosmos.

I find myself not bitter. I should be bitter, mad, or something.

Instead, I’m just fine. I’m bored. I’m quiet.

And yet… I have a lot to say, to express — but silence feels richer.

…

I cut my hair and I’m growing a beard-stache, or at least whatever I can make of it.

I usually go skinhead, but this time I didn’t.

Something’s off… something’s terribly off.

In the “coming down from the trees” aftermath, we are standing on the bridge of collapse as a civilization.

This A.I. threat is real—not in the Terminator sense, but in the repercussions it has on us, especially on new generations.

And yet, we are still asking the same question… still trying to construct meaning in a meaningless universe.

So why not just put on some bachatas and dance?

Dance, monkeys, dance!

why the fuck do I need to be seen?

i crave my privacy, and yet — this.

what a mess of a being, seemingly conscious.

i have my best moments watching the stars — no thoughts, nothing, just beams of light in the night.

i wonder if we crave connection because we’re wired to—namely, because we are social beings.

since we are born, we depend on others…

i want to travel to the stars… are you listening?

come and get me, please.

jesus fucking christ!

everywhere I go, there’s fucking a.i.

i’m just waiting for the restroom that eventually will have a.i. for whatever fucking reason.

i have no real take on the matter, so complaining seems off — but I think I’ll end up like john wick.

value. loyalty. above. all. else.

i’ve had it with people and their lack of values — especially when they’re too cowardly to be accountable, choosing instead to blame others. grow the fuck up.