Search
248 results for “LunaFreyja”
-
@LunaFreyja This is why I really love vertx.io. Almost everything is compile-time checked. Almost everything is explicit. But it is still very easy to use. #Eclipse #Vertx #java #reactive
-
@LunaFreyja This is why I really love vertx.io. Almost everything is compile-time checked. Almost everything is explicit. But it is still very easy to use. #Eclipse #Vertx #java #reactive
-
@LunaFreyja This is why I really love vertx.io. Almost everything is compile-time checked. Almost everything is explicit. But it is still very easy to use. #Eclipse #Vertx #java #reactive
-
@LunaFreyja This is why I really love vertx.io. Almost everything is compile-time checked. Almost everything is explicit. But it is still very easy to use. #Eclipse #Vertx #java #reactive
-
@LunaFreyja This is why I really love vertx.io. Almost everything is compile-time checked. Almost everything is explicit. But it is still very easy to use. #Eclipse #Vertx #java #reactive
-
@LunaFreyja Thank goodness #Maven uses #XML and not a cute #DSL based on a dynamic language that depends on ASM and #bytecode tricks. Why? Because I can freely upgrade to #JDK24 (or even #JDK25 EA) and Maven keeps chugging along, and no multiple weeks of waiting for a new compatible release ... (looks over at #Gradle and #Kotlin) #Java #OpenJDK
-
Our knowledge is limited by life
yet we shrink it further by denying people space to breath and to think.Instead of addressing the root cause, we keep polishing broken processes, reinventing the same problems, and proudly attaching square wheels to a cart that was meant to move forward. Progress does not come from pushing harder, it begins when we stop pretending the wheel was designed correctly.
#SoftwareEngineering #EngineeringLeadership #TechLeadership #Innovation #DeveloperExperience #PsychologicalSafety #FailureCulture #CriticalThinking #AI #Architecture #Leadership #TeamCulture #PragmaticEngineering
-
Our knowledge is limited by life
yet we shrink it further by denying people space to breath and to think.Instead of addressing the root cause, we keep polishing broken processes, reinventing the same problems, and proudly attaching square wheels to a cart that was meant to move forward. Progress does not come from pushing harder, it begins when we stop pretending the wheel was designed correctly.
#SoftwareEngineering #EngineeringLeadership #TechLeadership #Innovation #DeveloperExperience #PsychologicalSafety #FailureCulture #CriticalThinking #AI #Architecture #Leadership #TeamCulture #PragmaticEngineering
-
Our knowledge is limited by life
yet we shrink it further by denying people space to breath and to think.Instead of addressing the root cause, we keep polishing broken processes, reinventing the same problems, and proudly attaching square wheels to a cart that was meant to move forward. Progress does not come from pushing harder, it begins when we stop pretending the wheel was designed correctly.
#SoftwareEngineering #EngineeringLeadership #TechLeadership #Innovation #DeveloperExperience #PsychologicalSafety #FailureCulture #CriticalThinking #AI #Architecture #Leadership #TeamCulture #PragmaticEngineering
-
Our knowledge is limited by life
yet we shrink it further by denying people space to breath and to think.Instead of addressing the root cause, we keep polishing broken processes, reinventing the same problems, and proudly attaching square wheels to a cart that was meant to move forward. Progress does not come from pushing harder, it begins when we stop pretending the wheel was designed correctly.
#SoftwareEngineering #EngineeringLeadership #TechLeadership #Innovation #DeveloperExperience #PsychologicalSafety #FailureCulture #CriticalThinking #AI #Architecture #Leadership #TeamCulture #PragmaticEngineering
-
Our knowledge is limited by life
yet we shrink it further by denying people space to breath and to think.Instead of addressing the root cause, we keep polishing broken processes, reinventing the same problems, and proudly attaching square wheels to a cart that was meant to move forward. Progress does not come from pushing harder, it begins when we stop pretending the wheel was designed correctly.
#SoftwareEngineering #EngineeringLeadership #TechLeadership #Innovation #DeveloperExperience #PsychologicalSafety #FailureCulture #CriticalThinking #AI #Architecture #Leadership #TeamCulture #PragmaticEngineering
-
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 -
JUnit 6 broke 50 repos. I’m delighted.
If a dependency bump can shatter your stack, you don't need fewer updates. You need better tests.
I maintain 50+ OSS repos as one human. I don't babysit them. I automated everything, including updates and minor releases. Many repos haven't been touched in 6 years. AS now JUnit 6 rolled in, a chunk failed. Perfect.
Why perfect? Because failure is a signal, not a disaster. Good tests mean breakage never escapes. I've had repos fail on a Java date parser change. Beautiful. I saw it before release, fixed it, moved on. During Log4Shell and Spring4Shell I didn't panic. I just waited for the next update. That's what behaviour tests are for. And no, they are not slow. If your tests crawl, your design does too.
I trust code I write. I do not trust magic. I remove convenience glue that silently rots:
I don't need MultiValueMap when Map<List> is clearer.
I don't need StringUtils.isEmpty when a simple null or empty check is obvious.
I don't need annotations that smuggle in half a framework.Every extra library is a future liability: CVEs, Licences, Security, Data Privacy, Performance, breaking changes, mental overhead. Use them to start, then delete them to last. Fewer moving parts mean fewer ways to die.
After 6 years my micro systems still boot in micro seconds, still read clean, still behave. CI pipelines aged, sure, but the code stayed boring. Boring is freedom. Quiet, peaceful, done.
If your stack cannot auto-update without heart palpitations, the problem isn't updates. It's architecture.
Principles I ship by
Automate updates and everything else I can. Let tests be the gate, not fear.
Push behaviour tests to the edges. If it's slow, refactor until it isn't.
Prefer primitives and standard libs. Delete decorative wrappers.
Design for micro systems, not micro monoliths. Start fast, stay fast.
Fewer tools, fewer surprises, fewer nights on fire.Congratulations. The system failed safely. After fix, you may proceed to do literally anything else with your life.
#java #junit #testing #oss #automation #developerexperience #simplicity #minimalism #microservices #security #log4shell #spring4shell #cleanarchitecture
-
We don't need more. We need less.
Every week:
🧠 A new framework.
⚙️ A new "layer".
🤖 A new AI wrapper.
🔄 A new YAML format to abstract what used to be a shell script.And then we wonder:
"Why is our software hard to debug?"
"Why do our builds break randomly?"
"Why is onboarding a 6-month journey through tribal folklore?"I once said I write bug-free software that can be finished.
People laughed, especially product people.
Not because it's wrong.
But because they’ve forgotten it's possible.We build complexity on top of confusion:
A + B becomes C.
C + D becomes E.
Now, E is broken, and we would create a new layer, but nobody knows how A or B worked in the first place. For example HTML/JavaScript, we leave it there and just add layers around it.Take XML.
Everyone says it's ugly.
But you could validate it automatically, generate diagrams, enforce structure.
Now we're parsing YAML with 7 linters and still can't tell if a space is a bug.Take Gradle.
You can define catalogues, versioning, and settings, but can't update a dependency without reading 3 blogs and sacrificing a goat.
This is called "developer experience" now?Take Spring Boot.
I wouldn't trust a Spring Boot or any java Framework powered airplane.
Too many CVEs. Too much magic. Too little control.We don't need "smarter" tools.
We need dumber, boring, reliable defaults.Start boring.
Start small.
Then only change the 1% that needs to be fast, clever, or shiny.
You'll rarely even reach that point.
Like everyone says, "Y is more performant and faster than X", but no one reached the limit of X. Why should I care? Meanwhile, we use performant AI.Real engineering is not chasing hype.
It's understanding the system so deeply that you no longer need most of it.We've replaced curiosity with cargo cults.
We've replaced learning with LLM prompting.And somehow, we're surprised when AI loses to a 1980s Atari in a chess game.
At least the Atari understood its own memory.Simplicity = less maintenance = fewer bugs = happier teams.
We need less. Not more.
#devex #simplicity #softwareengineering #nocodependency#stopthehype #bugfree #springboot #gradle #xml #yamlhell #boringisgood #minimalism #AIhype #infrastructure #cleancode #pragmatism #java #NanoNative -
We don't need more. We need less.
Every week:
🧠 A new framework.
⚙️ A new "layer".
🤖 A new AI wrapper.
🔄 A new YAML format to abstract what used to be a shell script.And then we wonder:
"Why is our software hard to debug?"
"Why do our builds break randomly?"
"Why is onboarding a 6-month journey through tribal folklore?"I once said I write bug-free software that can be finished.
People laughed, especially product people.
Not because it's wrong.
But because they’ve forgotten it's possible.We build complexity on top of confusion:
A + B becomes C.
C + D becomes E.
Now, E is broken, and we would create a new layer, but nobody knows how A or B worked in the first place. For example HTML/JavaScript, we leave it there and just add layers around it.Take XML.
Everyone says it's ugly.
But you could validate it automatically, generate diagrams, enforce structure.
Now we're parsing YAML with 7 linters and still can't tell if a space is a bug.Take Gradle.
You can define catalogues, versioning, and settings, but can't update a dependency without reading 3 blogs and sacrificing a goat.
This is called "developer experience" now?Take Spring Boot.
I wouldn't trust a Spring Boot or any java Framework powered airplane.
Too many CVEs. Too much magic. Too little control.We don't need "smarter" tools.
We need dumber, boring, reliable defaults.Start boring.
Start small.
Then only change the 1% that needs to be fast, clever, or shiny.
You'll rarely even reach that point.
Like everyone says, "Y is more performant and faster than X", but no one reached the limit of X. Why should I care? Meanwhile, we use performant AI.Real engineering is not chasing hype.
It's understanding the system so deeply that you no longer need most of it.We've replaced curiosity with cargo cults.
We've replaced learning with LLM prompting.And somehow, we're surprised when AI loses to a 1980s Atari in a chess game.
At least the Atari understood its own memory.Simplicity = less maintenance = fewer bugs = happier teams.
We need less. Not more.
#devex #simplicity #softwareengineering #nocodependency#stopthehype #bugfree #springboot #gradle #xml #yamlhell #boringisgood #minimalism #AIhype #infrastructure #cleancode #pragmatism #java #NanoNative -
We don't need more. We need less.
Every week:
🧠 A new framework.
⚙️ A new "layer".
🤖 A new AI wrapper.
🔄 A new YAML format to abstract what used to be a shell script.And then we wonder:
"Why is our software hard to debug?"
"Why do our builds break randomly?"
"Why is onboarding a 6-month journey through tribal folklore?"I once said I write bug-free software that can be finished.
People laughed, especially product people.
Not because it's wrong.
But because they’ve forgotten it's possible.We build complexity on top of confusion:
A + B becomes C.
C + D becomes E.
Now, E is broken, and we would create a new layer, but nobody knows how A or B worked in the first place. For example HTML/JavaScript, we leave it there and just add layers around it.Take XML.
Everyone says it's ugly.
But you could validate it automatically, generate diagrams, enforce structure.
Now we're parsing YAML with 7 linters and still can't tell if a space is a bug.Take Gradle.
You can define catalogues, versioning, and settings, but can't update a dependency without reading 3 blogs and sacrificing a goat.
This is called "developer experience" now?Take Spring Boot.
I wouldn't trust a Spring Boot or any java Framework powered airplane.
Too many CVEs. Too much magic. Too little control.We don't need "smarter" tools.
We need dumber, boring, reliable defaults.Start boring.
Start small.
Then only change the 1% that needs to be fast, clever, or shiny.
You'll rarely even reach that point.
Like everyone says, "Y is more performant and faster than X", but no one reached the limit of X. Why should I care? Meanwhile, we use performant AI.Real engineering is not chasing hype.
It's understanding the system so deeply that you no longer need most of it.We've replaced curiosity with cargo cults.
We've replaced learning with LLM prompting.And somehow, we're surprised when AI loses to a 1980s Atari in a chess game.
At least the Atari understood its own memory.Simplicity = less maintenance = fewer bugs = happier teams.
We need less. Not more.
#devex #simplicity #softwareengineering #nocodependency#stopthehype #bugfree #springboot #gradle #xml #yamlhell #boringisgood #minimalism #AIhype #infrastructure #cleancode #pragmatism #java #NanoNative -
We don't need more. We need less.
Every week:
🧠 A new framework.
⚙️ A new "layer".
🤖 A new AI wrapper.
🔄 A new YAML format to abstract what used to be a shell script.And then we wonder:
"Why is our software hard to debug?"
"Why do our builds break randomly?"
"Why is onboarding a 6-month journey through tribal folklore?"I once said I write bug-free software that can be finished.
People laughed, especially product people.
Not because it's wrong.
But because they’ve forgotten it's possible.We build complexity on top of confusion:
A + B becomes C.
C + D becomes E.
Now, E is broken, and we would create a new layer, but nobody knows how A or B worked in the first place. For example HTML/JavaScript, we leave it there and just add layers around it.Take XML.
Everyone says it's ugly.
But you could validate it automatically, generate diagrams, enforce structure.
Now we're parsing YAML with 7 linters and still can't tell if a space is a bug.Take Gradle.
You can define catalogues, versioning, and settings, but can't update a dependency without reading 3 blogs and sacrificing a goat.
This is called "developer experience" now?Take Spring Boot.
I wouldn't trust a Spring Boot or any java Framework powered airplane.
Too many CVEs. Too much magic. Too little control.We don't need "smarter" tools.
We need dumber, boring, reliable defaults.Start boring.
Start small.
Then only change the 1% that needs to be fast, clever, or shiny.
You'll rarely even reach that point.
Like everyone says, "Y is more performant and faster than X", but no one reached the limit of X. Why should I care? Meanwhile, we use performant AI.Real engineering is not chasing hype.
It's understanding the system so deeply that you no longer need most of it.We've replaced curiosity with cargo cults.
We've replaced learning with LLM prompting.And somehow, we're surprised when AI loses to a 1980s Atari in a chess game.
At least the Atari understood its own memory.Simplicity = less maintenance = fewer bugs = happier teams.
We need less. Not more.
#devex #simplicity #softwareengineering #nocodependency#stopthehype #bugfree #springboot #gradle #xml #yamlhell #boringisgood #minimalism #AIhype #infrastructure #cleancode #pragmatism #java #NanoNative -
We don't need more. We need less.
Every week:
🧠 A new framework.
⚙️ A new "layer".
🤖 A new AI wrapper.
🔄 A new YAML format to abstract what used to be a shell script.And then we wonder:
"Why is our software hard to debug?"
"Why do our builds break randomly?"
"Why is onboarding a 6-month journey through tribal folklore?"I once said I write bug-free software that can be finished.
People laughed, especially product people.
Not because it's wrong.
But because they’ve forgotten it's possible.We build complexity on top of confusion:
A + B becomes C.
C + D becomes E.
Now, E is broken, and we would create a new layer, but nobody knows how A or B worked in the first place. For example HTML/JavaScript, we leave it there and just add layers around it.Take XML.
Everyone says it's ugly.
But you could validate it automatically, generate diagrams, enforce structure.
Now we're parsing YAML with 7 linters and still can't tell if a space is a bug.Take Gradle.
You can define catalogues, versioning, and settings, but can't update a dependency without reading 3 blogs and sacrificing a goat.
This is called "developer experience" now?Take Spring Boot.
I wouldn't trust a Spring Boot or any java Framework powered airplane.
Too many CVEs. Too much magic. Too little control.We don't need "smarter" tools.
We need dumber, boring, reliable defaults.Start boring.
Start small.
Then only change the 1% that needs to be fast, clever, or shiny.
You'll rarely even reach that point.
Like everyone says, "Y is more performant and faster than X", but no one reached the limit of X. Why should I care? Meanwhile, we use performant AI.Real engineering is not chasing hype.
It's understanding the system so deeply that you no longer need most of it.We've replaced curiosity with cargo cults.
We've replaced learning with LLM prompting.And somehow, we're surprised when AI loses to a 1980s Atari in a chess game.
At least the Atari understood its own memory.Simplicity = less maintenance = fewer bugs = happier teams.
We need less. Not more.
#devex #simplicity #softwareengineering #nocodependency#stopthehype #bugfree #springboot #gradle #xml #yamlhell #boringisgood #minimalism #AIhype #infrastructure #cleancode #pragmatism #java #NanoNative -
💰 Salary, 🌟 Development, 😊 Joy.
Everyone in your Team needs these values.
Pick two? You won't last.Yes, you can earn well without joy. But your weekends vanish. Your energy dies. Your money gets spent on escape.
Yes, you can love your job and get paid well. But if you're stuck with no growth, no challenge, eventually your spark fades.
And working forever on your weaknesses? That's not growth. That's managerial malpractice. Real development means doubling down on strengths, not sanding down your edges.
Also: the €5k difference between €95k and €100k? You won't feel it.
But the difference between €48k and €60k? That hits your daily.Want joy, growth, and sustainability?
→ Fewer roles.
→ Smaller teams.
→ Clearer direction.
→ Less compromise.
→ Room and Space for every role.That's how you build something that actually works.
#Leadership #TeamDesign #DeveloperExperience #WorkJoy #CareerGrowth #NoMoreBS #MinimalTeams #Productivity #FutureOfWork #PragmaticLeadership #TechCulture #WorkLifeDesign #TeamClarity
-
💡 Some people chase profits. Others build magic.
I love projects like this one:
👉 https://lnkd.in/dx2rU3unIt turns your MacBook trackpad into a digital scale.
No special hardware. No ads. No paywall. Just… curiosity turned into code.It hijacks the Force Touch sensors, calibrates raw pressure data, and gives you surprisingly accurate weight readings—all with your finger and a clever hack.
This is what I wish more tech looked like:
🧠 smart
🧰 simple
💸 not for saleWhile others gatekeep innovation behind SDKs and subscriptions, this project goes:
here’s how it works, enjoy.
Open Source with purpose, not polish for profit.It’s niche, odd, and brilliant.
And that’s exactly why it matters.To everyone trying to monetise every byte:
You’re missing the joy. You’re missing the point.To TrackWeight:
You nailed it.
Hacky, educational, experimental.
No evil. No upsell. Just exploration.
Thumbs up.#opensource #macos #trackpad #forceTouch #diytech #sideprojects #devtools #swiftui #buildinpublic #indietech #hardwarehacks #notforsale #curiositydriven #engineeringmagic #trackweight
-
💡 Some people chase profits. Others build magic.
I love projects like this one:
👉 https://lnkd.in/dx2rU3unIt turns your MacBook trackpad into a digital scale.
No special hardware. No ads. No paywall. Just… curiosity turned into code.It hijacks the Force Touch sensors, calibrates raw pressure data, and gives you surprisingly accurate weight readings—all with your finger and a clever hack.
This is what I wish more tech looked like:
🧠 smart
🧰 simple
💸 not for saleWhile others gatekeep innovation behind SDKs and subscriptions, this project goes:
here’s how it works, enjoy.
Open Source with purpose, not polish for profit.It’s niche, odd, and brilliant.
And that’s exactly why it matters.To everyone trying to monetise every byte:
You’re missing the joy. You’re missing the point.To TrackWeight:
You nailed it.
Hacky, educational, experimental.
No evil. No upsell. Just exploration.
Thumbs up.#opensource #macos #trackpad #forceTouch #diytech #sideprojects #devtools #swiftui #buildinpublic #indietech #hardwarehacks #notforsale #curiositydriven #engineeringmagic #trackweight
-
💡 Some people chase profits. Others build magic.
I love projects like this one:
👉 https://lnkd.in/dx2rU3unIt turns your MacBook trackpad into a digital scale.
No special hardware. No ads. No paywall. Just… curiosity turned into code.It hijacks the Force Touch sensors, calibrates raw pressure data, and gives you surprisingly accurate weight readings—all with your finger and a clever hack.
This is what I wish more tech looked like:
🧠 smart
🧰 simple
💸 not for saleWhile others gatekeep innovation behind SDKs and subscriptions, this project goes:
here’s how it works, enjoy.
Open Source with purpose, not polish for profit.It’s niche, odd, and brilliant.
And that’s exactly why it matters.To everyone trying to monetise every byte:
You’re missing the joy. You’re missing the point.To TrackWeight:
You nailed it.
Hacky, educational, experimental.
No evil. No upsell. Just exploration.
Thumbs up.#opensource #macos #trackpad #forceTouch #diytech #sideprojects #devtools #swiftui #buildinpublic #indietech #hardwarehacks #notforsale #curiositydriven #engineeringmagic #trackweight
-
💡 Some people chase profits. Others build magic.
I love projects like this one:
👉 https://lnkd.in/dx2rU3unIt turns your MacBook trackpad into a digital scale.
No special hardware. No ads. No paywall. Just… curiosity turned into code.It hijacks the Force Touch sensors, calibrates raw pressure data, and gives you surprisingly accurate weight readings—all with your finger and a clever hack.
This is what I wish more tech looked like:
🧠 smart
🧰 simple
💸 not for saleWhile others gatekeep innovation behind SDKs and subscriptions, this project goes:
here’s how it works, enjoy.
Open Source with purpose, not polish for profit.It’s niche, odd, and brilliant.
And that’s exactly why it matters.To everyone trying to monetise every byte:
You’re missing the joy. You’re missing the point.To TrackWeight:
You nailed it.
Hacky, educational, experimental.
No evil. No upsell. Just exploration.
Thumbs up.#opensource #macos #trackpad #forceTouch #diytech #sideprojects #devtools #swiftui #buildinpublic #indietech #hardwarehacks #notforsale #curiositydriven #engineeringmagic #trackweight
-
💡 Some people chase profits. Others build magic.
I love projects like this one:
👉 https://lnkd.in/dx2rU3unIt turns your MacBook trackpad into a digital scale.
No special hardware. No ads. No paywall. Just… curiosity turned into code.It hijacks the Force Touch sensors, calibrates raw pressure data, and gives you surprisingly accurate weight readings—all with your finger and a clever hack.
This is what I wish more tech looked like:
🧠 smart
🧰 simple
💸 not for saleWhile others gatekeep innovation behind SDKs and subscriptions, this project goes:
here’s how it works, enjoy.
Open Source with purpose, not polish for profit.It’s niche, odd, and brilliant.
And that’s exactly why it matters.To everyone trying to monetise every byte:
You’re missing the joy. You’re missing the point.To TrackWeight:
You nailed it.
Hacky, educational, experimental.
No evil. No upsell. Just exploration.
Thumbs up.#opensource #macos #trackpad #forceTouch #diytech #sideprojects #devtools #swiftui #buildinpublic #indietech #hardwarehacks #notforsale #curiositydriven #engineeringmagic #trackweight
-
JetBrains builds brilliant tools. No question. But somewhere along the way, something shifted. The IDE that once felt like a sleek exosuit now wears more like a lead apron. Familiar, powerful but exhausting.
Remember Eclipse? I do. Grew up with it. Then grew out of it, death by poor developer experience. I see echoes of that fate in JetBrains, and it terrifies me. Not because JetBrains is bad. But because it was once… fun.
I've seen more memory leaks, heavier startup times, and codebases that feel like they took a wrong turn into a garbage collector. A "Hello World" project now needs 5GB If I leave it open long enough. It starts asking me existential questions.
My IDE now eats up 15GB with simple projects. Caches? Massive. Often useless. Builds that run clean in terminal break in IntelliJ until I do the sacred dance: Build → Rebuild Project or Invalidate Caches. It's a modern ritual. I now default to my terminal. It's honest. It listens. It doesn't pretend.
Plugin development? A labyrinth. Testing plugins is like chasing asynchronous shadows. Documentation is scarce, SDKs mutate overnight, and the event system reminds me of a toddler with espresso. Thousands of change events for a single file edit. I wanted to build useful tools.
Even giants like AWS and CodePilot plugins throw random exceptions. Testing? What's that? The SDK laughs in JUnit.
The final twist: my own plugin, full of hope and effort, is now the ugliest code I've ever written. I can't fix it. I barely recognize it. I miss simplicity. I miss reliability. I miss fun.
JetBrains still has brilliance. But quality? It's slipping. The warning signs are glowing. Not with malice, but with entropy.
Would be poetic if a new IDE emerged soon. Just like JetBrains once did, fresh, small, efficient. Until then, I'll keep fighting caches, memory bloat, and undetectable test classes… while whispering my Eclipse shortcuts in IntelliJ like ancient spells.
Funny, isn't it? Software today feels less like writing code and more like running a game engine. But the bugs aren't part of the plot. They're just bugs.
#JetBrains #IntelliJ #PluginDevelopment #Java #DeveloperExperience #IDEThoughts #Kotlin #MemoryLeaks #BringBackFun #TerminalNeverLies
-
JetBrains builds brilliant tools. No question. But somewhere along the way, something shifted. The IDE that once felt like a sleek exosuit now wears more like a lead apron. Familiar, powerful but exhausting.
Remember Eclipse? I do. Grew up with it. Then grew out of it, death by poor developer experience. I see echoes of that fate in JetBrains, and it terrifies me. Not because JetBrains is bad. But because it was once… fun.
I've seen more memory leaks, heavier startup times, and codebases that feel like they took a wrong turn into a garbage collector. A "Hello World" project now needs 5GB If I leave it open long enough. It starts asking me existential questions.
My IDE now eats up 15GB with simple projects. Caches? Massive. Often useless. Builds that run clean in terminal break in IntelliJ until I do the sacred dance: Build → Rebuild Project or Invalidate Caches. It's a modern ritual. I now default to my terminal. It's honest. It listens. It doesn't pretend.
Plugin development? A labyrinth. Testing plugins is like chasing asynchronous shadows. Documentation is scarce, SDKs mutate overnight, and the event system reminds me of a toddler with espresso. Thousands of change events for a single file edit. I wanted to build useful tools.
Even giants like AWS and CodePilot plugins throw random exceptions. Testing? What's that? The SDK laughs in JUnit.
The final twist: my own plugin, full of hope and effort, is now the ugliest code I've ever written. I can't fix it. I barely recognize it. I miss simplicity. I miss reliability. I miss fun.
JetBrains still has brilliance. But quality? It's slipping. The warning signs are glowing. Not with malice, but with entropy.
Would be poetic if a new IDE emerged soon. Just like JetBrains once did, fresh, small, efficient. Until then, I'll keep fighting caches, memory bloat, and undetectable test classes… while whispering my Eclipse shortcuts in IntelliJ like ancient spells.
Funny, isn't it? Software today feels less like writing code and more like running a game engine. But the bugs aren't part of the plot. They're just bugs.
#JetBrains #IntelliJ #PluginDevelopment #Java #DeveloperExperience #IDEThoughts #Kotlin #MemoryLeaks #BringBackFun #TerminalNeverLies