Blog of Vincent VAUBAN

☕🤖 JAVA’S AGE is its AI SUPERPOWER

Sat, 26 Sep 2026 11:01:51 -0700

🔸 TL;DR

Java Champion Markus Eisele argues that Java’s history, strictness, specs, tooling and guardrails make it ideal for agentic enterprise development.

🔸 1️⃣0️⃣ MARKUS EISELE QUOTES

▪️ [“It is a very strict language, it is pretty type safe.”] / Clear constraints help agents read and generate code. / #Java

▪️ [“You know what, it's rock solid.”] / JVM stability becomes an advantage when AI touches production systems. / #JVM

▪️ [“Java itself is not the complication.”] / The hard part is legacy code, undocumented intent and old decisions. / #Legacy

▪️ [“So systematic change, almost surgically changing pieces that are guaranteed to work is a completely different requirement in my perspective compared to Vibe coding in loops.”] / Enterprise AI needs precision, not uncontrolled generation. / #AI

▪️ [“I have to admit, I lean towards precision engineering because it is just so much better to know what is actually changing, to be in Control.”] / Controlled change beats maximum generation. / #Engineering

▪️ [“Like, human in the loop to me means human in control.”] / Developers should stay inside the workflow, not only review the final diff. / #Control

☕➿ JAVA CERTIFICATION LOOP: can you find the OUTPUT in 20 seconds?

Sat, 26 Sep 2026 10:49:52 -0700

🔸 TLDR

You have 20 seconds. ⏱️

What does this Java code print?

No IDE.

No debugger.

No running the code. 👀

Just trace it like you would during a Java certification exam.

This tiny question combines:

▪️ i++ — use the value, then increment

▪️ ++i — increment first, then use the value

▪️ do-while — the body executes before the condition is checked

▪️ continue outer — jump directly to the loop condition

⏱️ Target time: 20 seconds

🔸 TAKEAWAYS

▪️ Never treat i++ and ++i as interchangeable.

▪️ With continue, check exactly where execution resumes.

▪️ In certification questions, trace variables statement by statement.

▪️ Tiny loops can test much more than loop syntax.

What does it print? 👇

#Java #JavaCertification #OCPJava #Java25 #JavaQuiz #JavaDeveloper #Programming #CodingChallenge #JavaProgramming

Go further with Java certification:

Java👇

https://bit.ly/javaOCP

Spring👇

☕🔮 If you’re only learning what’s stable in Java TODAY, you may already be LATE.

Sat, 26 Sep 2026 10:46:29 -0700

The next wave of Java is often visible before it becomes mainstream.

That’s exactly why my book is called Fullstack Dev 2027 for Java Tech.

Java doesn’t evolve only through features that are already final.

There are also:

▪️ Preview features

▪️ Incubator projects

▪️ Upcoming JVM capabilities

▪️ Experimental APIs

▪️ New approaches emerging across Spring, AI and backend engineering

Some of them will become mainstream.

Some will change.

Some may disappear.

But understanding them before everybody else does gives you something valuable:

👉 technical anticipation.

That’s why the book isn’t only about what Java development looks like today.

It also explores technologies and ideas that can shape the next releases and the next years.

The goal?

Not to predict the future perfectly.

It’s to make sure that when the future becomes production-ready, you’ve already seen it coming. 🚀

And of course, the book also covers the practical stack you need NOW:

▪️ Java & JVM

▪️ Spring Boot & Spring...Read More

☕🐢 PERFORMANCE PITFALLS in JPA and Friends

Sat, 26 Sep 2026 10:41:56 -0700

🔸 TLDR

JPA abstracts a lot of database complexity.

That convenience can also hide expensive connections, N+1 queries, eager fetching, unnecessary entity loading and transactions that live far longer than expected.

Jos Roseboom's talk is packed with practical reminders.

🎥 https://www.youtube.com/watch?v=RjnXUFyXlno

7️⃣PERFORMANCE LESSONS FROM THE TALK👇

1️⃣ ["it's like five five thousand times faster."]

Connection pooling isn't a tiny optimization. Reusing connections can be orders of magnitude faster than repeatedly creating new database connections.

#ConnectionPooling

2️⃣ ["the amount of connections is finite."]

A pool is fast, but not infinite. Holding connections longer than necessary can make unrelated requests wait and eventually threaten the availability of the whole application.

#HikariCP

3️⃣ ["by default it's fetched eager."]

JPA's default for @ManyToOne and owning-side @OneToOne can surprise you. Associations you never explicitly use may still trigger additional SQL.

#JPA

4️⃣ ["this is an N + 1 problem."]

One query retrieves the main result set, then additional queries are executed as associated entities are accessed. It looks harmless with 10 rows and painful with 10,000.

Ron Pressler's JavaOne 2026 argument flips the usual criticism of Java memory use:

Java's moving, generational GCs deliberately trade more RAM for less CPU overhead.

The real question is not “How little RAM does Java use?”

It is “How efficiently does it use the CPU + RAM we already paid for?”

🎥 https://www.youtube.com/watch?v=xr73mR7ii9M

🔸 1️⃣0️⃣ VERBATIMS

▪️ ["Together they form the spacetime of computation."]

Memory and processing are two sides of the same performance equation. #Performance

▪️ ["The program's footprint is always equal to the live set."]

Immediate reclamation minimizes footprint—but that can cost CPU. #Memory

▪️ ["Dynamic dispatch in Java is often faster than static dispatch in C++."]

Abstraction cost cannot be compared naively across languages. #JVM

▪️ ["Most objects die young."]

That empirical observation is the foundation of generational GC. #GarbageCollection

▪️ ["RAM chips become hardware accelerators."]

Extra heap headroom can reduce GC CPU overhead. #Java

▪️ ["There's no prize for using only 1% of RAM and 100% of the CPU."]

A tiny footprint is...Read More

☕🍃 SEQUENTIAL MICROSERVICES can quietly KILL your AVAILABILITY

Sat, 26 Sep 2026 10:36:36 -0700

🔸 TLDR

If one request requires Inventory → Payment → Transport to ALL succeed, your availability is not 99.5%.

It is the product of their availabilities.

▪️ Inventory: 99.5%

▪️ Payment: 99.5%

▪️ Transport: 99.5%

0.995 × 0.995 × 0.995 = 0.985074875

👉 Effective availability ≈ 98.51%

Under a simple independent-failure model, three “highly available” services just turned a 0.5% unavailability rate into ~1.49%.

Over a 30-day month:

▪️ One service at 99.5% ≈ 3h36 unavailable

▪️ The 3-service synchronous chain ≈ 10h45

And correlated failures can make reality worse.

🔸 WHY?

Your endpoint succeeds only if EVERY mandatory dependency succeeds.

❗One timeout.

‼️One network issue.

❗‼️One overloaded service.

AND

💥 The whole business operation fails.

And simply calling the services in parallel does NOT fix availability if all 3 results are still mandatory.

It mainly reduces latency.

🔸 HOW TO MITIGATE IT?

▪️ Short timeouts→ fail quickly instead of exhausting threads.

▪️ Retries→ useful for transient failures, but bounded + backoff.

▪️ Circuit breakers→ stop hammering an unhealthy dependency.

▪️ Bulkhead→...Read More

☕💰 The 1 MILLION question: what is that ~ SYMBOL in JAVA?

Sat, 26 Sep 2026 10:31:16 -0700

🔸 TLDR

~ is Java's bitwise complement operator.

It flips every bit:

▪️ 0 becomes 1

▪️ 1 becomes 0

And because Java represents signed integers using two's complement:

~x == -x - 1

So yes:

int x = 2;

System.out.println(~x); // -3

Why -3? 🤯

🔸 WHAT ACTUALLY HAPPENS?

In 32-bit binary, 2 starts like this:

00000000 00000000 00000000 00000010

Apply ~:

11111111 11111111 11111111 11111101

That bit pattern represents:

-3

So:

System.out.println(~2); // -3

System.out.println(~0); // -1

System.out.println(~1); // -2

System.out.println(~-1); // 0

System.out.println(~-2); // 1

The shortcut is:

~x = -(x + 1)

🔸 WHERE IS ~ ACTUALLY USEFUL?

A classic use is clearing bits from a bit mask:

int READ = 0b001;

int WRITE = 0b010;

int permissions = READ | WRITE;

// Remove WRITE

permissions = permissions & ~WRITE;

~WRITE flips the mask, then & clears precisely that bit.

On Rock the JVM, Trisha Gee explores AI, Stack Overflow, burnout, mentoring, junior careers, and the skills we must keep alive.

🔸 🔟 VERBATIMS

1️⃣ “Stack Overflow itself was part of a kind of revolution in how developers learned.”

It democratized knowledge. LLMs may replace the interface, not the need for expertise. #StackOverflow

2️⃣“we still need good quality answers, content, knowledge, materials in order to feed the machines with something helpful.”

AI still depends on strong human knowledge upstream. #AI

3️⃣ “you don't always have to understand the bits and bites in order to produce a product that is useful for customers, useful for the business.”

Fundamentals matter—but business value matters too. #SoftwareEngineering

4️⃣ “a lot of the AI stories are all around writing code, which was never the bottleneck in the first place”

Faster coding does not fix weak requirements, testing, delivery, or feedback loops. #Productivity

5️⃣ “I think we should not fall into the temptation of let's just do more stuff cuz we can do more stuff.”

AI speed without outcome thinking can create more code, and more debt. #TechDebt

6️⃣ “slow down. It's just like if your engineers are burning out, it's not working.”

More...Read More

🍃☕ SPRING MODULITH 2.2 M1: modular monoliths move to BOOT 4.2

Sat, 26 Sep 2026 09:47:28 -0700

🔸 TLDR

Spring Modulith helps turn a Spring Boot monolith into explicit, domain-driven modules whose boundaries can be verified, tested, observed and documented.

2.2 M1 moves to Spring Boot 4.2 M1 + Spring Framework 7.1 M1, while improving events, testing and auto-configuration.

🔸WHAT IS SPRING MODULITH?

A modular monolith keeps one deployable application while organizing the code into business-oriented modules.

Instead of hoping developers respect package boundaries, Spring Modulith can inspect and enforce them.

Think:

▪️ one application

▪️ multiple domain modules

▪️ explicit dependencies

▪️ architecture tests

▪️ module-focused integration tests

▪️ events between modules

You keep the operational simplicity of a monolith without accepting a giant ball of mud. 🧱

1️⃣ DECLARE MODULE DEPENDENCIES

The order module explicitly declares what it may depend on. This turns architectural intent into a rule the codebase can verify instead of leaving it buried in a diagram or README.

#ModularArchitecture

See: Read More

🎬🔁 Git RERERE: escape CHAINED PR INCEPTION

Sat, 26 Sep 2026 09:38:52 -0700

🔸 TLDR

git rerere = reuse recorded resolution.

Git remembers how you solved a conflict and can reuse it when the same conflict pattern appears again.

Perfect when stacked PRs are repeatedly rebased.

1️⃣ WHAT IS RERERE?

conflict → manual resolution → remembered

same conflict → resolution reused

It does NOT commit for you: review, then stage the result.

2️⃣ USE CASE

Rerere shines when you repeatedly merge or rebase branches and keep seeing the same conflicts.

3️⃣ THE 20-PR INCEPTION 🌀

Peter Lawrey summed it up:

“When you have 20 chained PRs and go back and forth between them, the movie Inception keeps coming to mind.”

Now PR2 changes:

PR2' → rebase PR3 → PR4 → ... → PR20

As you restack downward, old conflicts can return.

Rerere lets Git say:

“I’ve seen this conflict before.”

and replay the previous resolution.

4️⃣ HOW TO

Enable it once:

git config --global rerere.enabled true

Resolve the first conflict normally and git add it. Git records the resolution.

When a matching conflict returns, rerere can apply it automatically.

5️⃣...Read More