Spring I/O is one of the most important events for Java and Spring developers.

The 2026 edition happened in Barcelona (April 13–15) and brought what we expected: strong updates in Spring and a big focus on AI.

If you don’t have time to watch everything, here are the talks worth your attention.

🍃 Spring Boot 4 in Practice

Spring Boot 4 continues the same philosophy: developer productivity first, now with even broader capabilities.

If you want a quick overview, watch this session from Josh Long:

👉 Bootiful Spring Boot 4 — Josh Long

🤖 AI Is Now Real for Java Developers

AI was a central theme across multiple talks:

• Claude Code for Spring Developers by Thomas Schilling

• Comparing Agentic AI Frameworks for Java by Timo Salm / Sandra Ahlgrimm

• Spec-driven Development: How AI Changed Everything (And Nothing) by Simon Martinelli

▶️ Watch the Full Event

If you want to go deeper, you can watch all sessions here:

👉 Spring IO 2026 - Playlist

Conclusion

Big tech events are focusing more and more on AI, and Spring I/O 2026 clearly shows this trend.

If you want to stay relevant as a Java engineer, it’s important to keep learning how AI is being used in real applications. Spring I/O has many talks that can help you with that.

Have you attended the event or watched any sessions?
Share your opinion, and any talks you enjoyed.

Leave a comment

Keeping up with the Java ecosystem is not easy.

New frameworks, JVM updates, Spring improvements, and architecture trends appear all the time. If you don’t have a system, it’s easy to fall behind.

You can start here on DevJava where I share key updates, events, and practical insights. But to stay truly sharp, it’s important to follow multiple high-quality sources.

Here are some of the best ones I recommend.

☕ Oracle Java Blog

👉 https://dev.java/news/

The official Java blog from Oracle.
Best place to learn about new Java releases, language features, and JVM updates directly from the source.

📬 Graciano Weekly Newsletter

👉 https://graciano.dev/2024/11/01/weekend-reading-list-249/

A personal, well-curated list of articles and insights.
Perfect for discovering useful reads you might not find on your own.

🧩 InfoQ Java Articles

👉 https://www.infoq.com/java/articles/

Deep technical articles focused on architecture, scalability, and real-world systems.
Ideal for engineers who want to go beyond basics.

🌍 Foojay (Friends of OpenJDK)

👉 https://foojay.io/

A community-driven platform around OpenJDK.
Covers tools, news, and ecosystem updates with contributions from experts.

🍃 Spring Engineering Blog

👉 https://spring.io/blog/category/engineering?filter=series

Official Spring content with real engineering insights.
Great for learning about Spring Boot and Spring framework.

🧑‍💻 DevJava (This Blog)

A focused, practical view on Java backend, microservices, and productivity.
👉 The goal: help you become a better, faster, and more confident engineer.

Subscribe now

✅ Final Thoughts

Staying updated is not about consuming more, it’s about consuming the right information.

Most developers start using AI with simple prompts, and that works… until it doesn’t.

As soon as you need consistency, quality, and reliability, “just prompting” is not enough. You need structure, clear intent, and validation, just like in backend engineering.

That’s why prompt engineering is evolving into something bigger: a progression from quick experiments to well-designed, production-ready systems.

🧠 The 4 Levels of Prompt Engineering

1. Ad-hoc Prompting (Beginner)

You just ask the model and see what happens.

• ✔️ Fast

• ❌ Inconsistent

👉 Good for exploration, not for real systems.

2. Structured Prompting (Intermediate)

You start adding:

• Roles

• Examples

• Constraints

Prompts become reusable.

• ✔️ More reliable

• ✔️ Repeatable

• ❌ Still manual

3. System Prompting (Advanced)

Now prompts are part of a system:

• Templates

• Tools

• Guardrails

👉 This is where prompting becomes engineering.

4. Spec-Driven Prompting (Expert)

You define a specification first, then generate prompts from it.

• Spec = intent

• Prompt = execution

👉 This aligns with how we design good APIs: contract first, implementation later.

⚙️ The 3 Paradigms You Should Know

1. Vibe Coding (Exploration-first)

You describe what you want, and the AI figures it out.

• ✔️ Very fast

• ❌ Unpredictable

👉 Great for prototypes, risky for production.

2. Spec-Driven Development (Intent-first)

You define:

• Inputs

• Outputs

• Rules

• Edge cases

• ✔️ Clear and consistent

• ❌ Requires discipline

👉 Similar to designing a clean service contract in microservices.

3. Harness Engineering (System-first)

You build a system around the model:

• Tests

• Evaluations

• Feedback loops

• Retries

👉 Core idea: Don’t trust the model, validate it.

• ✔️ Production-ready

• ✔️ Measurable quality

• ❌ More complex

Conclusion

You start with Vibe to explore ideas fast.
Then move to Spec to bring clarity and structure.
And finally, use Harness to guarantee quality and reliability.

If you build Java backends, this flow should feel natural:

• You experiment

• You define contracts

• You add tests and validation

👉 Prompt engineering follows the same path.

Treat it like software engineering, with clear intent, good design, and strong feedback loops, and you’ll build AI systems that are not just impressive, but reliable and production-ready.

📚 References

• https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html

• https://martinfowler.com/articles/harness-engineering.html

• https://www.ibm.com/think/topics/vibe-coding

• https://learn.microsoft.com/pt-br/training/modules/spec-driven-development-github-spec-kit-greenfield-intro/

If you are serious about growing as a Java backend engineer, events like JCON Europe are worth your attention.

JCON Europe 2026 is one of the most relevant Java conferences in Europe, bringing together developers, architects, and community leaders to share real-world knowledge.

📅 What is JCON Europe?

JCON Europe is organized by the Java User Group Oberpfalz in collaboration with JAVAPRO Magazine.

The 2026 edition will take place on April 20th–23rd and includes:

• 1 full workshop day

• 3 days of conference sessions

You can expect topics like:

• Java and JVM internals

• Spring and microservices

• Cloud-native architecture

• Performance and scalability

This is not just theory, sessions usually focus on practical use cases and real production challenges.

🎟️ Free Ticket? Yes.

If you are part of a Java User Group (JUG), you can get a free ticket for all standard sessions.

👉 Get your ticket here: https://2026.europe.jcon.one/tickets

This is a great opportunity to learn from experts without spending money.

🎥 Can’t Attend? Watch Online

Most sessions are streamed on the JAVAPRO YouTube channel.

👉 Check out previous talks here:
https://www.youtube.com/@JAVAPRO-channel/search?query=jcon%202025

Even if you can’t attend live, you can still:

• Learn new concepts

• Stay updated with the Java ecosystem

• Improve your engineering skills

💡 Why You Should Care

Events like JCON are not just about watching talks. They help you:

• Stay relevant in a fast-changing ecosystem

• Learn from engineers solving real problems

• Discover better ways to design and build systems

Final Thoughts

JCON Europe 2026 is a great chance to invest in your growth, either by attending or watching online.

Have you attended JCON before? Or are you planning to join this year? Please, share your experience or expectations

Leave a comment

Big Trust: Rewire Self-Doubt, Find Your Confidence, and Fuel Success, written by Shade Zahrai, is a powerful book about overcoming self-doubt and building confidence.

It focuses on helping you get out of your comfort zone and break mental blocks that hold you back, something many developers experience during their careers.

The Doubt Profile

The book introduces four key attributes that shape how we deal with self-doubt:

1. Acceptance — Do you believe you’re enough as you are?

2. Agency — Do you trust your skills and abilities?

3. Autonomy — Do you feel you can shape your own path?

4. Adaptability — Can you stay emotionally grounded when doubt appears?

These attributes help you understand where your self-doubt comes from, and how to improve it.

Why Agency Matters (Especially for Developers)

One concept that stood out to me is Agency.

Agency means believing that you can figure things out.
It’s not just about what you already know, it’s about trusting your ability to learn, adapt, and solve problems.

For developers, this is essential.

We often face problems that:

• don’t have clear solutions

• have never been solved before

• require experimentation and learning

Being a developer means being a problem solver.
And without agency, it’s easy to feel stuck or overwhelmed.

When you experience a sense of Agency, you believe that you can figure things out. You not only believe that you have the skills you need, but also trust that you have the ability to adapt, learn, and solve problems as they come.

A Practical Reflection

If you don’t trust yourself to:

• handle new projects

• work on unfamiliar features

• fix complex bugs

then self-doubt may be limiting your growth.

Feeling fear when facing something new is normal.
But being frozen by that fear is what holds you back.

This book gives practical ways to reframe that fear and move forward with confidence.

Conclusion

Big Trust is a great read if you struggle with self-doubt or want to build more confidence in your career.

I didn’t go deep into all four attributes here, but if this topic resonates with you, I recommend reading the book and exploring it further.

You can also take a free assessment here:
👉 https://www.shadezahrai.com/doubtprofile

If you enjoyed this review, subscribe to the newsletter and share it with someone who might need more confidence in their journey 🚀

Hello! Let’s quickly review some common terms related to the Garbage Collector (GC) in the JVM.
Understanding these concepts can help you better analyze memory usage and performance issues in Java applications.

• Stop The World (STW):
  A moment when the JVM pauses all application threads to perform garbage collection tasks. During this pause, your application is temporarily stopped while the Garbage Collector reclaims memory or reorganizes the heap.

• Latency:
  The time it takes for your application to respond to a request. GC pauses can increase latency because the application is temporarily stopped.

• Throughput:
  The amount of work the application completes over time. Some garbage collectors focus on maximizing throughput instead of minimizing pause time.

  Example: Parallel GC, which focuses on completing more work even if pauses are longer.

• Pause Time:
  The duration of a GC pause. Different collectors are designed to reduce pause times depending on the system’s needs.

  Example: ZGC, which is designed to keep pause times very small, usually in the microseconds range.

• Java Heap:
  The Java Heap is the area of memory where objects are allocated.

  This is the main memory space managed by the Garbage Collector. When objects are no longer referenced, the GC frees that memory.

• Young Generation:
  The part of the heap where new objects are first allocated. Most objects have a short life and are collected here. Objects that survive several collections may be promoted to the Old Generation.

• Old Generation:
  Objects that survive longer are moved here. Garbage collections in this area happen less often but are usually heavier.

• Metaspace:
  The memory area where class metadata is stored, such as class definitions and method information. It replaced PermGen in Java 8 and uses native memory.

Understanding these basic terms makes it easier to reason about JVM performance and garbage collection behavior.

If you’d like a deeper explanation of how different Garbage Collectors work, let me know in the comments 🚀

Subscribe now

Do you know what the Garbage Collector (GC) in the JVM is?

If not, you can think of it as the silent hero of memory management. It quietly frees unused memory and saves developers from manual memory deallocation.

I won’t explain how it works here. If you’d like a deep dive on that, leave a comment, and I’ll write about it.

Leave a comment

What I want to talk about today is something practical: don’t just rely on the default Garbage Collector.

How Many Garbage Collectors Do We Have?

Depending on your Java version, OpenJDK offers five main Garbage Collectors:

• Serial GC

• Parallel GC

• G1 GC

• ZGC

• Shenandoah

Each GC is designed for different goals. Some focus on throughput, others on low latency. They also manage heap memory differently, which can significantly impact your application’s performance.

Choosing the wrong GC for your workload can cost you performance, stability, or memory efficiency.

What Is the Default GC?

The answer is: it depends 😅

According to the OpenJDK source code:

• If you have one processor or up to ~1.8 GB of RAM, the JVM uses Serial GC.

• If you have 2 or more processors and 1.8 GB+ of RAM, it uses G1 GC.

The default choice may work well, but that does not mean it is optimal for your system.

What About Microservices?

If you are running microservices, especially in containers, memory configuration becomes critical.

Many teams experience memory issues because they rely on defaults without understanding how the JVM behaves inside Kubernetes or Docker.

In many microservice scenarios, G1 GC is a solid and balanced choice. It provides good throughput and predictable pause times.

You can configure it explicitly, for example:

-XX:+UseG1GC
-XX:MaxRAMPercentage=75
-XX:InitialRAMPercentage=75

Heap sizing and RAM percentage tuning can make a big difference in container environments.

Learn More

If you want to understand how Java behaves in containers, I recommend these articles:

• https://learn.microsoft.com/en-us/azure/developer/java/containers/overview

• https://docs.oracle.com/en/java/javase/21/gctuning/ergonomics.html

And also this great talk by Bruno Borges: Secrets of Performance Tuning Java on Kubernetes

Final Thought

The Garbage Collector is not just an internal JVM detail. It directly affects performance, latency, and stability.

Don’t just use the default.

Understand your workload.
Test different configurations.
Measure the impact.

Performance tuning starts with awareness.

Hello! Java 26 was officially released this week, on March 17, 2026 🚀

A few weeks ago, I shared a preview of this version. If you want to revisit it, you can check it here:

I also created a GitHub repository with examples of some of the new features. Feel free to explore it if you want to try things out in practice.

Want to Learn More?

If you want a deeper understanding of what Java 26 brings, I highly recommend the videos by Billy Korando.

Depending on how much time you have:

• ⏱ No time?
  Java 26 in definitely UNDER 3 minutes

• ⏳ A bit of time?
  Unboxing Java 26 for Developers - Inside Java Newscast #108

• 📅 More time available?
  Java for an AI World - JavaOne Keynote

This last one is especially worth watching. It’s the keynote from JavaOne, one of the biggest Java events in the world, and it gives great insights into the future of Java.

Conclusion

Java 26 brings several interesting updates, and even if you don’t plan to use it in production yet, it’s worth staying up to date.

👉 If you enjoy this kind of content, subscribe to stay updated with Java news and insights 🚀

Working Effectively with Legacy Code (Robert C. Martin Series), written by Michael Feathers in 2004, is not a new book, but it is still extremely relevant.

If you work with legacy systems, this book can save you time, reduce stress, and help you avoid serious problems.

What Can We Do with Code?

Michael Feathers explains that there are four types of changes we usually make in a system:

• Bug fixes

• Adding new features

• Refactoring the code structure

• Optimization

When fixing bugs, we adjust existing behavior.
When adding features, we introduce new behavior.
When refactoring, we change the internal structure of the code.
When optimizing, we improve resource usage, similar to refactoring, but focused on performance.

Refactoring and optimization must preserve the same behavior. If behavior changes unintentionally, we introduce bugs.

And this is where the real challenge begins: how can we modify legacy code safely?

Two Ways to Change Code

According to the book, there are two common approaches:

Pray and Cover

This is probably the most common approach. You make the change carefully, run manual tests, and hope nothing breaks.

It feels fast, but it is risky.

Cover and Modify

This is the safer approach. Before changing the code, you add tests that protect the current behavior. Then you modify the code with confidence.

This idea connects directly to one of the most powerful lessons in the book.

Two Powerful Lessons

Here are two key ideas from the book:

“Dependency is one of the most critical problems in software development. Much legacy code work involves breaking dependencies so that change can be easier.”

Much of legacy work is about breaking dependencies so that change becomes easier and safer.

“Legacy code is simply code without tests.”

This idea changes everything. Legacy is not about age, it is about safety. If code has no tests, modifying it becomes risky.

Conclusion

This book teaches practical techniques to safely modify legacy systems while minimizing the risk of introducing bugs. It shows why tests are essential and how to add them even when the code was not designed for testing.

If you work with legacy systems, this book is highly recommended.

And now I’m curious:
📚 What is one book that has helped you grow as a developer? Share it in the comments.

Leave a comment

If you enjoyed this review, subscribe to the newsletter and share it with someone dealing with legacy code 🚀

It has been a while since I read Essentialism: The Disciplined Pursuit of Less by Greg McKeown. Recently, I revisited my notes and decided to share some key ideas — because this book can truly change how you think about work and life.

At its core, Essentialism is simple:

“The wisdom of life consists in eliminating what is non-essential.”

— Lin Yutang

Being an essentialist means focusing on less, but better.
It means choosing what really matters instead of trying to do everything.

The Problem: We Try to Do Too Much

The book challenges three common beliefs:

• “I have to do it.”

• “Everything is important.”

• “I can do both.”

Essentialism replaces them with:

• “I choose to do it.”

• “Only a few things truly matter.”

• “I can do anything, but not everything.”

If you feel overwhelmed, busy but not productive, or constantly moving without progress, this book speaks directly to you.

“If we don’t prioritize our life, someone else will.”

The Paradox of Success

One powerful idea in the book is the paradox of success:

1. We succeed because we are clear about our purpose.

2. Success brings more opportunities.

3. More opportunities create overload.

4. Overload destroys the clarity that made us successful.

Micro-managing everything does not scale. Focus does.

Essentialism in Practice

The path of the essentialist has three steps:

1. Explore

Ask yourself:
Which activity makes the highest contribution to my goal?

“Where is the wisdom we have lost in knowledge?”

— T. S. Eliot

Exploration requires space to think. Jeff Weiner (former LinkedIn CEO) blocks time in his calendar just to reflect. Thinking is not a luxury — it is strategy.

2. Eliminate

Saying no is one of the most important skills.

“Half the troubles of this life can be traced to saying yes too quickly and not saying no soon enough.”

— Josh Billings

A clear “no” is often kinder than a vague “maybe.”
Essentialists do not say yes to everything. They say yes to what truly matters.

3. Execute

Execution in Essentialism is not about moving faster. It is about preparing better.

“Give me six hours to chop down a tree and I will spend the first four sharpening the axe.”
— Abraham Lincoln

Preparation is not a waste of time, it is what makes execution easier.

The author talks about comprehensive preparation. When he was studying at Stanford, he planned the entire semester as soon as he received the syllabus. He identified major projects early and started working on them immediately. That small investment reduced stress for months. Even when unexpected events happened, he had enough margin to adapt.

Two practical lessons:

• Use comprehensive preparation. Plan ahead and give yourself margin for error. The future is uncertain, but preparation gives you control.

• Add 50% to your estimated time. Most people underestimate how long tasks take. Adding extra time reduces pressure and increases quality.

Final Thought

“Strategy is about making choices; it’s about deliberately choosing to be different”

— Michael Porter

The best outcome you can have from this book is to apply this rule:

When facing a decision, ask yourself: “What is essential?”
Answer honestly and eliminate the rest.

If this reflection helped you, subscribe to the newsletter and share it with someone who feels overwhelmed. Sometimes the real growth starts by doing less. 🚀

The book Microservices Up & Running: A Step-by-Step Guide to Building a Microservices Architecture is a practical book for developers working with microservices or planning to migrate from a monolith.

The book starts by explaining what microservices really are, not just small services, but systems organized around business responsibilities. The authors discuss Domain-Driven Design (DDD), Event Storming, and how team structure influences architecture.

One important message from the book is:

Microservices can make complex systems simpler, but they are not a silver bullet. Complexity is shifted, not magically removed.

This is a key lesson. Microservices do not eliminate complexity, they redistribute it. That requires discipline and good design.

The book also covers:

• ACID and consistency in distributed systems

• Event Sourcing and CQRS

• Infrastructure with AWS, Terraform, and Kubernetes

• CI/CD with GitHub Actions

• Deployment strategies like Canary and Blue-Green

Even though it is concise, the book touches on many essential subjects. If you are using microservices, or thinking about adopting them, understanding these concepts is an important step to avoid common struggles and truly benefit from this architecture style.

This book is realistic and practical. It explains both the technical and organizational sides of microservices.

If you are designing distributed systems or moving from a monolith, this is a valuable read.

If you enjoyed this review, subscribe to the newsletter and share it with someone working on microservices 🚀

Subscribe now

Java 26 is getting closer and is scheduled to be released in March 2026.
You can already access Early Access builds and start experimenting with the new features.

Java 26 will probably not be used by many projects in production, since most vendors will not support it as an LTS release, the next LTS target will be Java 29.

Even so, staying updated with non-LTS releases is important, because it helps you prepare and benefit more when the next LTS becomes available.

Let’s take a look at what’s new in Java 26.

What’s New in Java 26

Java 26 includes the following JEPs:

• JEP 500 – Prepare to Make Final Mean Final

• JEP 504 – Remove the Applet API

• JEP 516 – Ahead-of-Time Object Caching with Any GC

• JEP 517 – HTTP/3 for the HTTP Client API

• JEP 522 – G1 GC: Improve Throughput by Reducing Synchronization

• JEP 524 – PEM Encodings of Cryptographic Objects (Second Preview)

• JEP 525 – Structured Concurrency (Sixth Preview)

• JEP 526 – Lazy Constants (Second Preview)

• JEP 529 – Vector API (Eleventh Incubator)

• JEP 530 – Primitive Types in Patterns, instanceof, and switch (Fourth Preview)

As you can see, Java 26 brings some improvements in garbage collection and performance. The Applet API is finally gone 😢, but we’ll skip that topic for now. Instead, let’s focus on two updates that are especially interesting: JEP 526 and JEP 525.

JEP 526: Lazy Constants (Second Preview)

Lazy Constants allow you to initialize constants only when they are actually used, instead of during class loading. This can help reduce startup time and avoid unnecessary initialization.

public class LazyConstantExample {

    private static final LazyConstant<LazyClass> lazyClass = LazyConstant.of(() -> new LazyClass());

    public static void main(String[] args) {
        System.out.println(”Initialize”);
        lazyClass.get().printClassName();
        System.out.println(”End”);
    }

    private static class LazyClass {

        LazyClass() {
            System.out.println(”LazyClass created”);
        }

        public void printClassName() {
            System.out.println(this.getClass().getName());
        }
    }
}

The output from this class is:

Initialize
LazyClass created
com.bomfim.java26.LazyConstantExample$LazyClass
End

As shown, the class is created only when get() is called.

JEP 525: Structured Concurrency (Sixth Preview)

Structured Concurrency is still evolving, and I wanted to mention it here because I’ve already written about this topic before here:

That said, the API has changed a bit in Java 26, and yes, there are breaking changes 😲

But don’t worry, breaking changes are expected for preview features. This is exactly why you should be careful when using them in production.

The changes are not huge, mostly renaming and small adjustments. However if you followed my previous article on Structured Concurrency, that code will no longer work as-is.

Once this feature becomes stable, I’ll share an updated guide showing how to use it properly and how you can take advantage of it.

So feel free to subscribe to stay up to date with the latest Java news.

If you want to access the code, you can check it out here: https://github.com/ThiagoBfim/java-news

For more details about Java 26, I recommend taking a look at the official documentation: https://openjdk.org/projects/jdk/26/

Developer Career Masterplan: Build Your Path to Senior Level and Beyond with Practical Insights from Industry Experts, written by Bruno Souza and Heather Vancura, is one of the best career-focused books I’ve read.

This book is not about code, frameworks, or tools. It’s about building a sustainable and intentional career in software development, from junior to senior and beyond.

What the Book Is About

The authors share practical lessons that help developers grow professionally, such as:

• Getting out of your comfort zone

• Building and maintaining a strong network

• Developing soft skills

• Participating in communities

• Mentoring and being mentored

• Taking ownership of your career path

It’s a great read for developers who want more than just technical growth.

What Makes This Book Stand Out

One of the strongest points of this book is the interviews with industry professionals.
Through different perspectives, the book explores real experiences, challenges, and lessons learned across various career paths.

The Most Important Lesson (In My Opinion)

If I had to highlight one key message, it would be this:

👉 Be part of a community. Participate. Be visible.

You grow faster when you:

• Share what you know

• Share what you are learning

• Help others whenever you can

You don’t need to be an expert to contribute. Visibility comes from consistency and being a giver, not perfection.

Conclusion

Developer Career Masterplan is a must-read for anyone who wants to take control of their career in IT. It reminds us that technical skills matter, but people, communication, and community matter just as much.

If this review helped you, subscribe to the newsletter and share it with someone who wants to grow their developer career 🚀

Subscribe now

Recently, I read Forever Strong: A New, Science-Based Strategy for Aging Well by Dr. Gabrielle Lyon.
This book is especially valuable for people who are not in good physical shape or physically active.

Most developers spend long hours sitting in front of a computer. Over time, this affects not only our bodies, but also our energy, focus, and productivity. Strength training and healthy eating are essential for a more vital life.

The book shares five fundamental attributes that apply not only to fitness, but also to career growth, and life in general. To become healthier or better at your job, the first step is changing your mindset.

1. Be Brave

Being brave is your best defence against unexpected changes.

Life and career will force you into uncomfortable situations. Instead of holding on to excuses about your past or present, bravery means facing problems directly and moving forward, even when it’s hard.

Growth always starts outside your comfort zone.

2. Perseverance

Perseverance is the ability to keep going despite difficulties or delayed rewards.

You will fail. Probably many times.
What matters is your willingness to get up again.

Patience and self-compassion are essential. Perseverance works quietly, but over time, it creates real change.

3. Self-Discipline

Discipline imposed from outside is limited. Self-discipline comes from internal control.

The best way to improve self-discipline is to plan for your weaknesses. Don’t rely on motivation alone; design your environment and routine, so the right choice becomes the easy one.

4. Adaptability

Perfectionism is a trap, especially when it comes to health and long-term plans.

Adaptability is your best ally.
When the unexpected breaks your routine, commit to finding solutions instead of excuses. Adjust the plan, but don’t abandon it.

5. Resilience

Resilience is the ability to return to balance after a setback.

Unexpected events can break routines, delay goals, and trigger negative thoughts. Resilience means regaining emotional strength, refocusing, and continuing, without letting temporary failures define you.

Conclusion

Forever Strong is not just about muscles, it’s about building a mindset that supports long-term success. These five attributes apply equally to health, career, and personal growth.

Small habits, repeated consistently, create strong people 💪

Mastering API Architecture approaches REST and API design from a theoretical and architectural perspective. Instead of focusing on implementation details, it explains how and why API-based systems should be designed, operated, and evolved.

The book covers topics such as:

• REST principles and architectural trade-offs

• Testing strategies

• API Gateways and Service Mesh

• Security considerations

• Deployment and evolution patterns

It is recommended for senior developers, architects, and tech leads. Mid-level engineers can also benefit, especially those who want to deepen their architectural understanding.

What Makes This Book Different

This is not a step-by-step or beginner-friendly guide.
Although it includes examples and a journey from a monolith to a cloud-based system, the focus is not on “how to code”, but on decision-making.

The authors rely heavily on:

• Architectural Decision Records (ADRs)

• Clear explanations of trade-offs

• Long-term API evolution strategies

This makes the book especially valuable for professionals responsible for API stability, governance, and growth.

Book Details

• Title: Mastering API Architecture: Design, Operate, and Evolve API-Based Systems

• Authors: James Gough, Daniel Bryant, Matthew Auburn

• Published: 2022

• Pages: 286

Conclusion

If you want to improve how you think about API architecture, this book is an excellent choice. It helps you understand trade-offs and make better decisions when evolving APIs, skills that truly matter at senior levels.

👉 If this review helped you, subscribe to the newsletter and share it with someone who designs APIs.
More content like this is coming every week 🚀

Subscribe now

Spring Boot 4.0 was released on November 20, 2025, built on top of Spring Framework 7.0.
After almost three years since Spring Boot 3 (late 2022), this new major release brings important improvements and new features across the platform.

Support status: why this matters

Looking at the current support timeline:

• Spring Boot 3.4 → OSS support has ended

• Spring Boot 3.5 → short OSS support, ending on 30 Jun 2026

• Spring Boot 4.0 → nearly one year of OSS support (until 31 Dec 2026) and a longer commercial window

If you’re on 3.4, upgrading is no longer optional. If you’re on 3.5, the clock is ticking. Moving to 4.0 gives you more runway and access to the newest features built on Spring Framework 7.0.

What’s new?

Spring Boot 4.0 and Spring Framework 7.0 bring several enhancements. Here’s a practical overview of some of the highlights:

👉 Spring Framework 7.0 – API Versioning

How to upgrade safely

The Spring team provides a clear, step-by-step migration guide covering breaking changes and required adjustments:

👉 Spring Boot 4.0 Migration Guide
https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.0-Migration-Guide

To understand what’s new at the framework level, review the official notes:

👉 Spring Framework 7.0 Release Notes
https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-7.0-Release-Notes

🚀 Enjoyed this update?

👉 Subscribe for free to get weekly Spring & Java insights
👍 Like this post to help DevJava reach more developers

Subscribe now

Spring Framework 7.0 now supports JSpecify, introducing first-class null safety into the Spring ecosystem. This means Spring can understand nullability contracts and help you detect potential NullPointerException issues at compile time, not in production.

What Is Null-safety?

Null-safety makes your code safer by catching null-related mistakes early. It creates clear expectations:

• What can be null

• What cannot be null

• What APIs require strict checks

This leads to fewer runtime surprises and more reliable applications.

What Is JSpecify?

JSpecify defines standard annotations such as:

• @NonNull

• @Nullable

• @NullMarked

Spring 7 understands these annotations and applies null-safety rules consistently across your beans and application logic.

📘 JSpecify guide: https://jspecify.dev/docs/user-guide/
📘 Spring null-safety docs: https://docs.spring.io/spring-framework/reference/core/null-safety.html

How to Enable Null-safety Checks (Maven)

To validate null-safety automatically, we use NullAway, Uber’s fast, compile-time checker, together with Error Prone:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <source>17</source>
        <target>8</target>
        <encoding>UTF-8</encoding>
        <compilerArgs>
            <arg>-XDcompilePolicy=simple</arg>
            <arg>--should-stop=ifError=FLOW</arg>
            <arg>-Xplugin:ErrorProne
                -XepOpt:NullAway:AnnotatedPackages=com.bomfim
                -Xep:NullAway:ERROR
                -XepExcludedPaths:.*/src/test/java/.*
            </arg>
        </compilerArgs>
        <annotationProcessorPaths>
            <path>
                <groupId>com.google.errorprone</groupId>
                <artifactId>error_prone_core</artifactId>
                <version>2.42.0</version>
            </path>
            <path>
                <groupId>com.uber.nullaway</groupId>
                <artifactId>nullaway</artifactId>
                <version>0.12.12</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

What this setup gives you

• Compile-time null-safety enforcement

• Clear errors when annotations are violated

• Automatic protection against accidental null values

More details:
📘 NullAway JSpecify Support: https://github.com/uber/NullAway/wiki/JSpecify-Support

You can access the code here: https://github.com/ThiagoBfim/spring-news

Using Gradle?

This talk explains it perfectly:
🎥 Null Safety in Java with JSpecify and NullAway — Sébastien Deleuze (Spring I/O 2025)

Conclusion

With Spring 7 + JSpecify + NullAway, Java finally gets a practical, lightweight approach to null-safety. You get earlier warnings, clearer APIs, and fewer runtime surprises, all with minimal setup.

If you found this useful, subscribe for free and hit like, more Spring & Java tips coming every week 🚀

Subscribe now

Spring Framework 7.0 introduces out-of-the-box resilience features, making it easier to protect your application against overload and instability. These features are part of the spring-context module and can be enabled with: @EnableResilientMethods

Spring 7 brings two main resilience annotations:

• @ConcurrencyLimit

• @Retryable

In this article, we’ll focus on @ConcurrencyLimit and why it becomes especially important in the era of Virtual Threads.

Why Concurrency Control Matters

With Virtual Threads, Java applications can handle a much higher number of concurrent requests. This is great for throughput and responsiveness, but it also introduces new risks:

• Higher memory usage

• Increased pressure on databases and external services

• Risk of overwhelming downstream systems

Scaling without limits can easily turn into self-inflicted denial of service.

That’s exactly the problem @ConcurrencyLimit helps solve.

What @ConcurrencyLimit Does

The @ConcurrencyLimit annotation allows you to define how many concurrent executions a method can have.

When the limit is reached:

• Additional calls are queued internally

• No extra threads are created

• The system remains stable and predictable

This is especially useful when enabling Virtual Threads but still needing to protect external dependencies.

Example Usage

@Async
@ConcurrencyLimit(100)
public CompletableFuture<List<Application>> findAll() {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException(e);
    }
    return CompletableFuture.completedFuture(
            List.of(new Application(Thread.currentThread().getName()))
    );
}

What’s happening here

• The method can run at most 100 times in parallel

• Extra calls wait in an internal queue

• This prevents overload while still allowing high concurrency

This is a simple but powerful safety net when working with Virtual Threads.

You can access the code here: https://github.com/ThiagoBfim/spring-news

When Should You Use It?

@ConcurrencyLimit is a great choice when:

• You’re adopting Virtual Threads

• Your application depends on slower or fragile external systems

• You want controlled scalability instead of unlimited parallelism

Conclusion

Spring Framework 7.0 makes resilience easier and more accessible.
@ConcurrencyLimit gives you a simple way to scale safely, especially in modern, highly concurrent applications.

If you want to go deeper into Virtual Threads, I’ve written about them here:

If you enjoyed this content, subscribe for free and hit the like button.

Subscribe now

References

• Spring Framework Resilience Documentation

• Core Spring Resilience Features: @ConcurrencyLimit, @Retryable, and RetryTemplate

Have you already defined your goals for 2026? Should you?
Let’s take a moment to understand why having a clear path matters and how you can set goals that actually help you grow.

There’s a quote I really like:

“If you don’t know where you are going, any road will get you there”

In other words: If you don’t decide your destination, life will choose one for you.

Why Goals Matter

The key to success is not perfection, it’s consistency.
Having a plan helps you stay on track, even when you’re tired, lazy, or not in your best moment.

You can fail along the way.
You can slow down.
But you cannot give up.

Another quote that fits perfectly here is the famous one from Michael Jordan:

“I’ve missed more than 9,000 shots in my career. I’ve lost almost 300 games. 26 times I’ve been trusted to take the game-winning shot and missed. I’ve failed over and over and over again in my life. And that is why I succeed.”

— Michael Jordan

Success is not about always winning, it’s about not stopping.

Define Your Goals

Think about a few things you want to achieve this year. Examples:

• Run 10 km

• Give a talk at an event

• Earn 10% more

These are great goals, but they are outcomes.
To make them real, you need to take action.

Turn Goals into SMART Actions

SMART goals are a simple way to create clear and achievable objectives.

S — Specific

Clear and focused. You know exactly what you want.

M — Measurable

You can track progress with numbers or checkpoints.

A — Achievable

Realistic for your current situation, not impossible.

R — Relevant

Aligned with your bigger goals and what truly matters to you.

T — Time-bound

Has a deadline or timeframe to keep you accountable.

Example:
❌ “I want to run more.”
✔️ “I will run 10 km by June, adding 300 meters every week.”

SMART goals turn ideas into actions, and actions into progress.

Example: Run 10 km

Instead of trying to run 10 km right away, define:

• Every Thursday and Sunday, run 300 meters more.

Start with 300 meters.
Next week: +300 meters.
Week after: +300 meters again.

Specific. Achievable. Consistent.

Example: Eat healthier

“Stop eating junk food” is too big and too vague.

Try something like:

• Eat junk food at most 2 times per week.

• Eat sugary food only once per week.

These rules are realistic and easy to follow. Over time, you can adjust them closer to your final goal.

Action + Plan = Progress

A plan without action is just a dream.
Action without a plan is a path without direction.

But when you combine both, a clear plan + consistent action, you create real progress.

Happy New Year 🎉

I wish you an amazing 2026.
I hope you achieve your goals, grow your career, and move one step closer to the life you want.

Every week, I’ll be sharing a new post to help you grow as a developer, especially in the Java world.
This is also one of my goals for the year 😄.

If you want to follow this journey with me, subscribe for free and let’s grow together. 💪🚀

Spring Framework 7.0, released on November 13, 2025, introduces several new features, and one of the most useful for API work is the new API versioning support.

Spring now provides a clean, built-in way to configure API versions using the ApiVersionConfigurer. You can set up versioning through Java configuration or application.properties, define default versions, and even configure deprecation handling.

In this guide, we look at a simple example using a custom HTTP header (x-version) as the versioning strategy.

Configuring API Versioning

The first step is to implement the configureApiVersioning method:

@Configuration
public class WebConfiguration implements WebMvcConfigurer {

    @Override
    public void configureApiVersioning(ApiVersionConfigurer configurer) {
        StandardApiVersionDeprecationHandler deprecationHandler =
                new StandardApiVersionDeprecationHandler();

        LocalDateTime deprecatedDate = LocalDateTime.of(2026, 5, 30, 0, 0);
        deprecationHandler.configureVersion(”v1”)
                .setDeprecationDate(ZonedDateTime.of(deprecatedDate, ZoneId.of(”UTC”)));

        configurer
                .useRequestHeader(”x-version”)
                .addSupportedVersions(”v1”, “v2”)
                .setDeprecationHandler(deprecationHandler)
                .setDefaultVersion(”v2”);
    }
}

In this configuration:

• We support two API versions: v1 and v2

• v1 is marked as deprecated

• Spring automatically adds a Deprecation header following RFC 9745

• You can also implement a Sunset header (RFC 8594) if needed

• The default version is v2

Versioning in the Controller

Now let’s see a simple controller using versioned mappings.

@RestController
public class ApplicationController {

    private final ApplicationService applicationService;

    public ApplicationController(ApplicationService applicationService) {
        this.applicationService = applicationService;
    }

    @GetMapping(value = “/app”, version = “v1”)
    public ResponseEntity<List<Application>> getApp() {
        return ResponseEntity.ok(applicationService.findAll().join());
    }

    @GetMapping(value = “/app”, version = “v2”)
    public ResponseEntity<List<Application>> getAppV2() {
        return ResponseEntity.ok(applicationService.findAll().join());
    }
}

What the Response Looks Like

Calling v1

HTTP/1.1 200
Deprecation: @1780099200
Content-Type: application/json

You receive a Deprecation header because v1 has an expiry date.

Calling v2

HTTP/1.1 200
Content-Type: application/json

Conclusion

In my opinion, this approach may not be the most practical solution for HTTP API versioning itself, but it is extremely helpful for:

• applying RFC 9745 (Deprecation header)

• applying RFC 8594 (Sunset header)

• validating API versions and returning clear exceptions

• keeping your API evolution predictable and well-structured

If you want to dive deeper, here are two great resources:

📘 https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-config/api-version.html
📘 https://www.danvega.dev/blog/spring-boot-4-api-versioning?ref=apisyouwonthate.com

You can access the code here: https://github.com/ThiagoBfim/spring-news