#unixphilosophy — Public Fediverse posts

So, I rescued a 12-year-old Macbook Pro, given up by its owner because Apple had orphaned it from security updates, and also it was suffering from Apple High-Qwality Spicy Pillow Syndrome.

I replaced the battery and installed Linux on it.

And I gotta say, this was the most satisfying thing I've done with a keyboard in years:

# apt-get purge systemd libnss-systemd

#Devuan Excalibur installed/upgraded from Debian Trixie like a champ. Now I don't have to deal with extraneous horseshit when Lennart adds systemd-mountd, systemd-sshd, systemd-bourne-shell, systemd-emacs, etc, etc...

Thanks to @landley for the post that finally convinced me to give Devuan a go. I'd been thinking about it for years, but didn't feel like setting aside a bunch of debugging time which I assumed would be needed.

Now to figure out how to switch to s6 from runit. ( @ska )

#Debian #systemd #UnixPhilosophy #runit #s6 #init #Unix #Linux

@pfr

Okay, now we just have to fork it to strip out the systemd.

#systemd #Unix #UnixPhilosophy #LennartPoettering #s6 #init #Linux #BSD

Post-OOP Imperative Functional Java.
Model the process. Not the domain.

Most Java code still asks the wrong question:
"What is this domain object?"
But production systems fail, scale, and burn because of processes, not nouns.

If your system is a sequence of irreversible steps, model it as a sequence,
not as interacting objects pretending to be immortal.

This follows ideas from Railway-Oriented Programming (ROP):
errors and decisions are values, not control-flow side effects.

Modeling the process means you can read this top to bottom
and understand exactly what happens.
No debugger. No IDE magic. No tribal knowledge.

Control flow is explicit.
You see the execution order.
Nothing hides in constructors, annotations, or overrides.

Failure is a first-class concept.
Once it fails or decides early, nothing else runs.
No exception archaeology.

Processes > Objects.
Real systems are workflows where refactoring is safe.

Steps are reordered, removed, or replaced
without collapsing a class hierarchy.
Testing is trivial, small stepwise context — even for an AI.

Feed input. Assert final result.
No mocking five layers of indirection.

GraalVM / native-friendly.
No reflection rituals.
The compiler smiles.

Objects are great for long-lived entities.
User actions, payments, rules, and failures are short-lived processes.

I model what happens,
not what pretends to exist forever.

Influenced by:
Railway-Oriented Programming,
Functional Core / Imperative Shell,
Workflow / Saga patterns,
Command pipelines,
Unix philosophy,
and value-oriented libraries like Vanilla-DI.

Don't be stuck in axioms.

#PostOOP
#ImperativeFunctional
#ProcessOverObjects
#ModelTheProcess
#WorkflowFirst
#RailwayOrientedProgramming
#FunctionalCore
#ImperativeShell
#CommandPipeline
#ExplicitControlFlow
#ValueOrientedDesign
#ProcessModeling
#FailFast
#NoExceptionArchaeology
#ComposableSystems
#NativeFriendly
#GraalVM
#NoReflection
#DeterministicCode
#RefactorSafe
#SagaPattern
#UnixPhilosophy
#VanillaDI
#ModernJava
#ArchitectureMatters

Post-OOP Imperative Functional Java.
Model the process. Not the domain.

Most Java code still asks the wrong question:
"What is this domain object?"
But production systems fail, scale, and burn because of processes, not nouns.

If your system is a sequence of irreversible steps, model it as a sequence,
not as interacting objects pretending to be immortal.

This follows ideas from Railway-Oriented Programming (ROP):
errors and decisions are values, not control-flow side effects.

Modeling the process means you can read this top to bottom
and understand exactly what happens.
No debugger. No IDE magic. No tribal knowledge.

Control flow is explicit.
You see the execution order.
Nothing hides in constructors, annotations, or overrides.

Failure is a first-class concept.
Once it fails or decides early, nothing else runs.
No exception archaeology.

Processes > Objects.
Real systems are workflows where refactoring is safe.

Steps are reordered, removed, or replaced
without collapsing a class hierarchy.
Testing is trivial, small stepwise context — even for an AI.

Feed input. Assert final result.
No mocking five layers of indirection.

GraalVM / native-friendly.
No reflection rituals.
The compiler smiles.

Objects are great for long-lived entities.
User actions, payments, rules, and failures are short-lived processes.

I model what happens,
not what pretends to exist forever.

Influenced by:
Railway-Oriented Programming,
Functional Core / Imperative Shell,
Workflow / Saga patterns,
Command pipelines,
Unix philosophy,
and value-oriented libraries like Vanilla-DI.

Don't be stuck in axioms.

#PostOOP
#ImperativeFunctional
#ProcessOverObjects
#ModelTheProcess
#WorkflowFirst
#RailwayOrientedProgramming
#FunctionalCore
#ImperativeShell
#CommandPipeline
#ExplicitControlFlow
#ValueOrientedDesign
#ProcessModeling
#FailFast
#NoExceptionArchaeology
#ComposableSystems
#NativeFriendly
#GraalVM
#NoReflection
#DeterministicCode
#RefactorSafe
#SagaPattern
#UnixPhilosophy
#VanillaDI
#ModernJava
#ArchitectureMatters

Post-OOP Imperative Functional Java.
Model the process. Not the domain.

Most Java code still asks the wrong question:
"What is this domain object?"
But production systems fail, scale, and burn because of processes, not nouns.

If your system is a sequence of irreversible steps, model it as a sequence,
not as interacting objects pretending to be immortal.

This follows ideas from Railway-Oriented Programming (ROP):
errors and decisions are values, not control-flow side effects.

Modeling the process means you can read this top to bottom
and understand exactly what happens.
No debugger. No IDE magic. No tribal knowledge.

Control flow is explicit.
You see the execution order.
Nothing hides in constructors, annotations, or overrides.

Failure is a first-class concept.
Once it fails or decides early, nothing else runs.
No exception archaeology.

Processes > Objects.
Real systems are workflows where refactoring is safe.

Steps are reordered, removed, or replaced
without collapsing a class hierarchy.
Testing is trivial, small stepwise context — even for an AI.

Feed input. Assert final result.
No mocking five layers of indirection.

GraalVM / native-friendly.
No reflection rituals.
The compiler smiles.

Objects are great for long-lived entities.
User actions, payments, rules, and failures are short-lived processes.

I model what happens,
not what pretends to exist forever.

Influenced by:
Railway-Oriented Programming,
Functional Core / Imperative Shell,
Workflow / Saga patterns,
Command pipelines,
Unix philosophy,
and value-oriented libraries like Vanilla-DI.

Don't be stuck in axioms.

#PostOOP
#ImperativeFunctional
#ProcessOverObjects
#ModelTheProcess
#WorkflowFirst
#RailwayOrientedProgramming
#FunctionalCore
#ImperativeShell
#CommandPipeline
#ExplicitControlFlow
#ValueOrientedDesign
#ProcessModeling
#FailFast
#NoExceptionArchaeology
#ComposableSystems
#NativeFriendly
#GraalVM
#NoReflection
#DeterministicCode
#RefactorSafe
#SagaPattern
#UnixPhilosophy
#VanillaDI
#ModernJava
#ArchitectureMatters

Post-OOP Imperative Functional Java.
Model the process. Not the domain.

Most Java code still asks the wrong question:
"What is this domain object?"
But production systems fail, scale, and burn because of processes, not nouns.

If your system is a sequence of irreversible steps, model it as a sequence,
not as interacting objects pretending to be immortal.

This follows ideas from Railway-Oriented Programming (ROP):
errors and decisions are values, not control-flow side effects.

Modeling the process means you can read this top to bottom
and understand exactly what happens.
No debugger. No IDE magic. No tribal knowledge.

Control flow is explicit.
You see the execution order.
Nothing hides in constructors, annotations, or overrides.

Failure is a first-class concept.
Once it fails or decides early, nothing else runs.
No exception archaeology.

Processes > Objects.
Real systems are workflows where refactoring is safe.

Steps are reordered, removed, or replaced
without collapsing a class hierarchy.
Testing is trivial, small stepwise context — even for an AI.

Feed input. Assert final result.
No mocking five layers of indirection.

GraalVM / native-friendly.
No reflection rituals.
The compiler smiles.

Objects are great for long-lived entities.
User actions, payments, rules, and failures are short-lived processes.

I model what happens,
not what pretends to exist forever.

Influenced by:
Railway-Oriented Programming,
Functional Core / Imperative Shell,
Workflow / Saga patterns,
Command pipelines,
Unix philosophy,
and value-oriented libraries like Vanilla-DI.

Don't be stuck in axioms.

#PostOOP
#ImperativeFunctional
#ProcessOverObjects
#ModelTheProcess
#WorkflowFirst
#RailwayOrientedProgramming
#FunctionalCore
#ImperativeShell
#CommandPipeline
#ExplicitControlFlow
#ValueOrientedDesign
#ProcessModeling
#FailFast
#NoExceptionArchaeology
#ComposableSystems
#NativeFriendly
#GraalVM
#NoReflection
#DeterministicCode
#RefactorSafe
#SagaPattern
#UnixPhilosophy
#VanillaDI
#ModernJava
#ArchitectureMatters

Post-OOP Imperative Functional Java.
Model the process. Not the domain.

Most Java code still asks the wrong question:
"What is this domain object?"
But production systems fail, scale, and burn because of processes, not nouns.

If your system is a sequence of irreversible steps, model it as a sequence,
not as interacting objects pretending to be immortal.

This follows ideas from Railway-Oriented Programming (ROP):
errors and decisions are values, not control-flow side effects.

Modeling the process means you can read this top to bottom
and understand exactly what happens.
No debugger. No IDE magic. No tribal knowledge.

Control flow is explicit.
You see the execution order.
Nothing hides in constructors, annotations, or overrides.

Failure is a first-class concept.
Once it fails or decides early, nothing else runs.
No exception archaeology.

Processes > Objects.
Real systems are workflows where refactoring is safe.

Steps are reordered, removed, or replaced
without collapsing a class hierarchy.
Testing is trivial, small stepwise context — even for an AI.

Feed input. Assert final result.
No mocking five layers of indirection.

GraalVM / native-friendly.
No reflection rituals.
The compiler smiles.

Objects are great for long-lived entities.
User actions, payments, rules, and failures are short-lived processes.

I model what happens,
not what pretends to exist forever.

Influenced by:
Railway-Oriented Programming,
Functional Core / Imperative Shell,
Workflow / Saga patterns,
Command pipelines,
Unix philosophy,
and value-oriented libraries like Vanilla-DI.

Don't be stuck in axioms.

#PostOOP
#ImperativeFunctional
#ProcessOverObjects
#ModelTheProcess
#WorkflowFirst
#RailwayOrientedProgramming
#FunctionalCore
#ImperativeShell
#CommandPipeline
#ExplicitControlFlow
#ValueOrientedDesign
#ProcessModeling
#FailFast
#NoExceptionArchaeology
#ComposableSystems
#NativeFriendly
#GraalVM
#NoReflection
#DeterministicCode
#RefactorSafe
#SagaPattern
#UnixPhilosophy
#VanillaDI
#ModernJava
#ArchitectureMatters

Those who fail to understand Unix are doomed to forever keep trying to turn it into Windows NT.

#Unix #UnixPhilosophy #simplicity #OneJob #systemd #Windows #WindowsNT

Listen at: https://archives.anonradio.net/202504020000_screwtape.mp3

This week we will talk about the Unix Philosophy and how it compares and contrasts with whatever one might call the “Emacs Philosophy.”

The impetus for the discussion is a series of blog posts by @ramin_hal9001 called “Emacs fulfills the UNIX Philosophy”:

• The original introductory blog post
• The show notes

…as well as a fascinating discussion that took place over this past week on ActivityPub on the topic of the Unix philosophy and history of Lisp on Unix in which some very knowledgeable people have contributed anecdotes and facts.

#technology #programming #SoftwareEngineering #RetroComputing #lisp #r7rs #SchemeLang #UnixPhilosophy

within each of us
our loved ones, in tiny form,
caring's innate yield
    company at a distance
    legacy in case of loss

#senryu #poem #ShortPoem #SmallPoem #SmallPoems

@besserwisser
<mostly_joking_self_promotion>
Well, in that case, I've written a #minimalist password generator you should try!

#passgen is a CLI app to generate secure passphrases that are easy to type (for when you can't paste). And it follows the #unixPhilosophy, and lets you pipe it's output to standard-out (or, optionally, have it in your clipboard). https://passgen.codesections.com/

</mostly_joking_self_promotion>