Search
189 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 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
-
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 -
💰 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
-
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
-
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
-
TECHNICAL DEBT is like a ROTTING ROOF
On rainy days, it's too wet to fix it.
On sunny days, there's no leak… so you ignore it.
Then one day, boom, ceiling caves in, buckets everywhere, and you're duct taping production at 2am.That's technical debt.
Not just messy code. Not just bad practices.
It's what you chose not to fix when you could have.The missing tests.
The config you hardcoded "just for now".
The abstraction you skipped because "it works".
The one extra iteration after the ticket was marked as "done".And now it's slowing you down.
It's holding your future hostage.
You're spending engineering cycles bailing water, not shipping value.We love to say we're "building", but half the time we're just… leak managers.
You can't scale rot.So next time the sun's out, fix the roof.
Because when the rain hits, it's too late.#TechnicalDebt #SoftwareEngineering #Minimalism #DevEx #LegacyCode #BuildRight #PragmaticEngineering #TechLeadership #CodeQuality #DeveloperExperience #SustainableSoftware #TeamVelocity #FixTheRoof
-
I'm Now an Official NATS Maintainer! 🎉.
The votes are in, and I'm deeply honoured to join the NATS maintainers list, This is more than just a title. It's a moment of genuine pride.
Years ago, I got tired of the complexities and overhead that came with traditional messaging systems. Kafka? Powerful, yes, but exhausting. Then I discovered NATS. Brutally simple, elegant in design, and feature-rich without the bloat. Clustering, multi tenancy, portability – it just works. And that changed everything for me.
As a Java developer, I wanted to bring NATS into my ecosystem. As i love meaningful tests, I've built testing tools for it. For JUnit, Spring Boot, and plain Java.
The goal? The same philosophy as NATS: simple, reliable, user-friendly. These tools now have high test coverage, automation, and are easy to extend – just like NATS inspired me to do.Open source became more than a hobby. It became my space. A place where I can contribute, grow, take ownership, and be appreciated globally. There are no politics, no "office vs home office" debates, no gatekeeping. Just a community building solid, high quality software that the world relies on.
I'll never forget when Synadia reached out and allowed me to use the NATS logo for my libs and even sent me a package from the USA. That personal written letter? Still on my desk. A reminder that kindness and recognition can come from anywhere.
In OSS, I don't follow OKRs, SCRUMs, or agile charts. I follow curiosity, quality, and contribution. And I believe this is where innovation really thrives.
💡 One thing I still hope for: that more developers and companies recognize NATS as the powerful tool it is. Yes, there were recent changes in the CNCF relationship and yes, it raised questions. But the APL-licensed NATS is here to stay. And it's still gold.
Companies build their businesses on OSS. I hope one day they'll also support it financially or through real contributions. Without open source, there is no modern software and no Business.
To everyone in the NATS and broader OSS community: thank you. I'm proud to be one of you. @Scott, @Ginger, @derek
#NATS #OpenSource #Java #Messaging #ProudMaintainer #DevLife #Synadia #SoftwareEngineering #Innovation #Gratitude
-
Developers can summon 20,000 lines of framework incantations.
But writing 100 lines of pure Java, and suddenly, their keyboards break.Frameworks were supposed to simplify things. Instead, we’ve built microservices with the elegance of a collapsing Jenga tower. Defended layers on layers of “necessary” abstractions, all just to call a method.
Java, on the other hand?
Solid. Modern. Dangerous in the right hands.
Especially when wielded with jlink, jpackage, pr the surgical precision of GraalVM native executables.From time to time, it’s good to step away from the glue. Touch the metal to actually feel something again.
(PS: Java Logging format still sucks. But we can’t all be perfect.) ☠️🧠💻
#PlainJava #GraalVM #MinimalismIsNotAMyth #CodeLikeYouMeanIt #coding #java #programming #developers
-
Why @Annotations Will Eventually Burn You.
Preach annotation voodoo or embrace explicit method calls? Too many still cling to @PreAuthorize, entrusting their fate to framework black magic. But such blind faith is brittle. One innocent Spring Boot update, and suddenly your security vanishes unless you summon an obscure @Enable... incantation.
Prefer the custom preauthorize() method: it’s concrete, predictable, and the compiler screams when something breaks as it should. Just like how constructor injection finally defeated the field-injection cult, it’s time to retire annotation worship elsewhere too.
Consider @JsonProperty("fieldName"): sure, the object mapper might infer names correctly without it, until one day it doesn’t, because the naming strategy changes behind your back. It’s happened. It will happen again. That’s the price of depending on invisible magic. Unreadable, unpredictable, unmaintainable. Same applies to reflection.
Frameworks and their “best practices” are relics of the monolith age. Java has evolved: threads, HTTP services, logging,… all can now be built functionally, fluently, and natively. It’s not Java vs Kotlin or some trendy syntax candy. Languages, especially those that compile, already give you more than enough. The bottleneck isn’t the tool, it’s the one holding it.
#Java #SpringBoot #CleanCode #SoftwareEngineering #CodeQuality #Programming #ModernJava #DeveloperExperience #DevMindset #NoMoreMagic #ReadableCode #ExplicitOverImplicit #SayNoToAnnotations #SeparationOfConcerns #FunctionalProgramming
-
Why @Annotations Will Eventually Burn You.
Preach annotation voodoo or embrace explicit method calls? Too many still cling to @PreAuthorize, entrusting their fate to framework black magic. But such blind faith is brittle. One innocent Spring Boot update, and suddenly your security vanishes unless you summon an obscure @Enable... incantation.
Prefer the custom preauthorize() method: it’s concrete, predictable, and the compiler screams when something breaks as it should. Just like how constructor injection finally defeated the field-injection cult, it’s time to retire annotation worship elsewhere too.
Consider @JsonProperty("fieldName"): sure, the object mapper might infer names correctly without it, until one day it doesn’t, because the naming strategy changes behind your back. It’s happened. It will happen again. That’s the price of depending on invisible magic. Unreadable, unpredictable, unmaintainable. Same applies to reflection.
Frameworks and their “best practices” are relics of the monolith age. Java has evolved: threads, HTTP services, logging,… all can now be built functionally, fluently, and natively. It’s not Java vs Kotlin or some trendy syntax candy. Languages, especially those that compile, already give you more than enough. The bottleneck isn’t the tool, it’s the one holding it.
#Java #SpringBoot #CleanCode #SoftwareEngineering #CodeQuality #Programming #ModernJava #DeveloperExperience #DevMindset #NoMoreMagic #ReadableCode #ExplicitOverImplicit #SayNoToAnnotations #SeparationOfConcerns #FunctionalProgramming
-
Why @Annotations Will Eventually Burn You.
Preach annotation voodoo or embrace explicit method calls? Too many still cling to @PreAuthorize, entrusting their fate to framework black magic. But such blind faith is brittle. One innocent Spring Boot update, and suddenly your security vanishes unless you summon an obscure @Enable... incantation.
Prefer the custom preauthorize() method: it’s concrete, predictable, and the compiler screams when something breaks as it should. Just like how constructor injection finally defeated the field-injection cult, it’s time to retire annotation worship elsewhere too.
Consider @JsonProperty("fieldName"): sure, the object mapper might infer names correctly without it, until one day it doesn’t, because the naming strategy changes behind your back. It’s happened. It will happen again. That’s the price of depending on invisible magic. Unreadable, unpredictable, unmaintainable. Same applies to reflection.
Frameworks and their “best practices” are relics of the monolith age. Java has evolved: threads, HTTP services, logging,… all can now be built functionally, fluently, and natively. It’s not Java vs Kotlin or some trendy syntax candy. Languages, especially those that compile, already give you more than enough. The bottleneck isn’t the tool, it’s the one holding it.
#Java #SpringBoot #CleanCode #SoftwareEngineering #CodeQuality #Programming #ModernJava #DeveloperExperience #DevMindset #NoMoreMagic #ReadableCode #ExplicitOverImplicit #SayNoToAnnotations #SeparationOfConcerns #FunctionalProgramming
-
Why @Annotations Will Eventually Burn You.
Preach annotation voodoo or embrace explicit method calls? Too many still cling to @PreAuthorize, entrusting their fate to framework black magic. But such blind faith is brittle. One innocent Spring Boot update, and suddenly your security vanishes unless you summon an obscure @Enable... incantation.
Prefer the custom preauthorize() method: it’s concrete, predictable, and the compiler screams when something breaks as it should. Just like how constructor injection finally defeated the field-injection cult, it’s time to retire annotation worship elsewhere too.
Consider @JsonProperty("fieldName"): sure, the object mapper might infer names correctly without it, until one day it doesn’t, because the naming strategy changes behind your back. It’s happened. It will happen again. That’s the price of depending on invisible magic. Unreadable, unpredictable, unmaintainable. Same applies to reflection.
Frameworks and their “best practices” are relics of the monolith age. Java has evolved: threads, HTTP services, logging,… all can now be built functionally, fluently, and natively. It’s not Java vs Kotlin or some trendy syntax candy. Languages, especially those that compile, already give you more than enough. The bottleneck isn’t the tool, it’s the one holding it.
#Java #SpringBoot #CleanCode #SoftwareEngineering #CodeQuality #Programming #ModernJava #DeveloperExperience #DevMindset #NoMoreMagic #ReadableCode #ExplicitOverImplicit #SayNoToAnnotations #SeparationOfConcerns #FunctionalProgramming
-
Why @Annotations Will Eventually Burn You.
Preach annotation voodoo or embrace explicit method calls? Too many still cling to @PreAuthorize, entrusting their fate to framework black magic. But such blind faith is brittle. One innocent Spring Boot update, and suddenly your security vanishes unless you summon an obscure @Enable... incantation.
Prefer the custom preauthorize() method: it’s concrete, predictable, and the compiler screams when something breaks as it should. Just like how constructor injection finally defeated the field-injection cult, it’s time to retire annotation worship elsewhere too.
Consider @JsonProperty("fieldName"): sure, the object mapper might infer names correctly without it, until one day it doesn’t, because the naming strategy changes behind your back. It’s happened. It will happen again. That’s the price of depending on invisible magic. Unreadable, unpredictable, unmaintainable. Same applies to reflection.
Frameworks and their “best practices” are relics of the monolith age. Java has evolved: threads, HTTP services, logging,… all can now be built functionally, fluently, and natively. It’s not Java vs Kotlin or some trendy syntax candy. Languages, especially those that compile, already give you more than enough. The bottleneck isn’t the tool, it’s the one holding it.
#Java #SpringBoot #CleanCode #SoftwareEngineering #CodeQuality #Programming #ModernJava #DeveloperExperience #DevMindset #NoMoreMagic #ReadableCode #ExplicitOverImplicit #SayNoToAnnotations #SeparationOfConcerns #FunctionalProgramming
-
Zero Trust Login
How I Stopped Reading Your Data in my servicesI build systems where not even the almighty admin (me) can read your data.
No backdoors. No db.users.find(). Just encrypted chaos. Beautiful, unreadable, untouchable chaos.Security isn't magic, we are just scared to lose control.
If I'm debugging live prod data, I've already failed my architecture exam.Many pretend to do the same using JWTs/JWKs. Cute. But let's be honest:
There's always someone with access. Production isn't a vault, it's just a cleaner sandbox.Most systems cling to readable tokens, human friendly JSON, and debug services like a comfort blanket.
I don't.Zero trust could work like this:
1. User signs up
➤ They give a password.
➤ I derive a unique key from that password.
➤ That key encrypts a randomly generated User Key.
➤ That User Key encrypts everything else (emails, usernames, secrets, hopes, dreams).2. User logs in
➤ Same password = same derived key.
➤ That unlocks their User Key.
➤ That unlocks their encrypted data.
➤ Voilà. Magic. But not magic. Math.3. Token generation
➤ It has no traceable info and All Session Data are encrypted with the backend-only key.
➤ It expires. Quickly.
➤ It is fingerprinted to the device/browser.
➤ You steal it? Good luck. Doesn’t work on your laptop, Dave.👁️ Zero Visibility ≠ Zero Functionality
• 🔒 I can’t decrypt your data. Not even if I'm angry.
• 🛡️ Backend is stateless. Frontend is stateless. Token is everything.
• 👨💻 No user ID in memory. No session storage. No cookies.
• 🪪 You want access? Bring your password, WebAuthn, 2FA or other login methods.
• 🕵️ No OAuth weirdness, no redirect hell.
• 🧠 Works like OAuth, but with actual privacy. Not even a user ID is exposed
• ⚙️ Agnostic to used technologies - Cloud, OnPremise, SQL, NoSQL, doesn't matter.Because security isn't magic. It's math, discipline, and just enough spite to not let anyone (including yourself) peek behind the curtain.
Until then, I'll be in the server room. Giggling at encrypted documents I can't read.
#ZeroTrust #Encryption #Security #Stateless #PrivacyByDesign #BackendOnlyAccess #NoRootForYou #Coding #Programming
-
Zero Trust Login
How I Stopped Reading Your Data in my servicesI build systems where not even the almighty admin (me) can read your data.
No backdoors. No db.users.find(). Just encrypted chaos. Beautiful, unreadable, untouchable chaos.Security isn't magic, we are just scared to lose control.
If I'm debugging live prod data, I've already failed my architecture exam.Many pretend to do the same using JWTs/JWKs. Cute. But let's be honest:
There's always someone with access. Production isn't a vault, it's just a cleaner sandbox.Most systems cling to readable tokens, human friendly JSON, and debug services like a comfort blanket.
I don't.Zero trust could work like this:
1. User signs up
➤ They give a password.
➤ I derive a unique key from that password.
➤ That key encrypts a randomly generated User Key.
➤ That User Key encrypts everything else (emails, usernames, secrets, hopes, dreams).2. User logs in
➤ Same password = same derived key.
➤ That unlocks their User Key.
➤ That unlocks their encrypted data.
➤ Voilà. Magic. But not magic. Math.3. Token generation
➤ It has no traceable info and All Session Data are encrypted with the backend-only key.
➤ It expires. Quickly.
➤ It is fingerprinted to the device/browser.
➤ You steal it? Good luck. Doesn’t work on your laptop, Dave.👁️ Zero Visibility ≠ Zero Functionality
• 🔒 I can’t decrypt your data. Not even if I'm angry.
• 🛡️ Backend is stateless. Frontend is stateless. Token is everything.
• 👨💻 No user ID in memory. No session storage. No cookies.
• 🪪 You want access? Bring your password, WebAuthn, 2FA or other login methods.
• 🕵️ No OAuth weirdness, no redirect hell.
• 🧠 Works like OAuth, but with actual privacy. Not even a user ID is exposed
• ⚙️ Agnostic to used technologies - Cloud, OnPremise, SQL, NoSQL, doesn't matter.Because security isn't magic. It's math, discipline, and just enough spite to not let anyone (including yourself) peek behind the curtain.
Until then, I'll be in the server room. Giggling at encrypted documents I can't read.
#ZeroTrust #Encryption #Security #Stateless #PrivacyByDesign #BackendOnlyAccess #NoRootForYou #Coding #Programming