In REST APIs, GET is the standard method for retrieving resources.

It works well for simple filters:

GET /products?category=books&sort=price

But what happens when the filter becomes more complex?

Multiple criteria, nested objects, long lists, and advanced search conditions can quickly make the URL difficult to read, or even exceed URL length limits.

A common workaround is to create a POST endpoint, with the search criteria in the request body.

Although practical, this approach has a downside: POST was not designed for safe, idempotent queries. It mixes data retrieval with a method primarily intended for creating or processing resources.

💡 The Solution: HTTP QUERY

In June 2026, the IETF published RFC 10008, introducing a new HTTP method: QUERY.

The goal is simple:

Allow complex queries in the request body while keeping the semantics of a read-only operation.

Instead of overloading POST, you can now write:

QUERY /contacts HTTP/1.1
Host: example.org
Content-Type: application/x-www-form-urlencoded
Accept: application/json

select=surname,givenname,email&limit=10&match=%22email=*@example.*%22

📖 Learn More

If you’re designing modern REST APIs, RFC 10008 is worth reading:

👉 https://www.rfc-editor.org/info/rfc10008/

If you’re looking to stay up to date with Java, Spring, AI, and the JVM ecosystem, IntelliJ IDEA Conf 2026 is an event worth adding to your calendar.

The conference takes place September 8–9 and is completely free. Over two days, you’ll find practical sessions on Java language updates, JVM internals, frameworks, performance, developer productivity, and AI, all presented by industry experts.

👉 Register for free: https://lp.jetbrains.com/intellij-idea-conf-2026/

🎤 Talks Worth Watching

The agenda is packed with great content. Here are some highlights:

• Now and Next Java for AI — Ana-Maria Mihalceanu

• Spec-Driven Development With AI Agents: From High-Level Requirements to Working Software — Anton Arhipov

• Safeguarding YOLO Developer Workflows With Docker — Oleg Šelajev

• Codepocalypse Now: LangChain4j vs JetBrains Koog— Baruch Sadogursky & Viktor Gamov

• The Past, Present, and Future of Enterprise Java — Ivar Grimstad

• RoboCoders: Judgment Day: AI Agents Face Off — Baruch Sadogursky & Viktor Gamov

• Bootiful IntelliJ IDEA — Josh Long

💡 Why You Should Attend

This year’s agenda covers the topics shaping the future of Java development, from AI and spec-driven development to the latest improvements in the Java ecosystem.

Whether you want to improve your productivity or explore new technologies, there’s something for every Java developer.

Which session are you looking forward to the most? Share it in the comments!

Leave a comment

Hello,

It’s been a while since our last post!

Recently, a friend shared a great deal with me, and I wanted to pass it along to you.

Packt is currently running a promotion where you can get any book for only $9.99. This includes my book, Mastering RESTful Web Services with Java, which is available at more than 70% off:

👉 https://www.packtpub.com/en-us/product/mastering-restful-web-services-with-java-9781835462584

If you’ve been thinking about improving your Java backend, REST API, or microservices skills, this is a great opportunity to grab some quality resources at a very low price.

The promotion is available for a limited time, so don’t wait too long.

Happy reading!

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