Articles & Resources #

Becoming a good Java developer isn’t just about memorizing syntax or knowing how to use a framework. It’s about building a deep understanding of how the JVM works, how to design systems that can grow, and how to write code that other people can maintain — including yourself six months from now. This page curates the most useful resources across various categories: books that will change how you write code, official documentation that should always be your first reference, tools that speed up development, and communities where you can grow alongside other developers. Every recommendation here was chosen based on one criterion: will this make you a better developer?

Books #

Programming Foundations — Required Reading #

These books aren’t Java-specific, but they teach principles that apply to every language and outlast framework trends by far.

Clean Code — Robert C. Martin

The most recommended book about writing code that humans can read, not just computers. It covers good naming, short focused functions, useful comments, and refactoring. The examples use Java, so it’s highly relevant. Read this before any technical book.

The Pragmatic Programmer — David Thomas & Andrew Hunt

Broader than Clean Code — it covers the philosophy of being a professional developer: from effective learning, managing technical debt, systematic debugging, to communicating with your team. The latest edition (20th Anniversary) is updated for the modern era.

Refactoring: Improving the Design of Existing Code — Martin Fowler

A catalog of refactoring techniques with very clear before-and-after examples. The second edition uses JavaScript, but the concepts are universal. This book changes how you see existing code — not as “bad code” but as “code that needs to evolve”.

Design Patterns — Gang of Four (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides)

The classic book that introduced 23 design patterns. Heavy and formal, but it’s the shared vocabulary used by the entire industry. Read it after you have at least 1-2 years of practical experience — patterns are much easier to understand in the context of real problems.

Java-Specific #

Effective Java — Joshua Bloch

Written by one of Java’s own architects. It contains 90 best-practice items for writing effective, safe, and performant Java code — from using generics correctly, avoiding concurrency traps, to safe serialization. The third edition covers Java 9 and above. This is the most important Java book besides the official documentation.

Java Concurrency in Practice — Brian Goetz et al.

The best book about concurrent programming in Java. It covers the Java memory model, thread safety, locks, atomic variables, and the executor framework with a depth found in no other book. Although written in 2006, the concepts remain relevant because it explains foundations that haven’t changed much.

Modern Java in Action — Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft

The most complete guide to modern Java features (8 and above): lambdas, the Stream API, Optional, CompletableFuture, reactive streams, and modules. Very practical with lots of code examples. Suitable for developers who know old Java but want to upgrade to modern Java.

Java Performance — Scott Oaks

This book covers how the JVM works, garbage collection, JIT compilation, and profiling. Suitable after you have 2-3 years of experience and start facing performance problems in production. Reading it will change how you write code because you begin to understand what happens behind the scenes.

Architecture and Systems #

Designing Data-Intensive Applications — Martin Kleppmann

The best book ever written about distributed systems. It covers databases, replication, partitioning, transactions, and consistency with extraordinary depth. Highly relevant for developers working with Kafka, distributed databases, or microservices. There’s no Java code, but the concepts are directly applicable.

Building Microservices — Sam Newman

A practical guide to building a microservice architecture from scratch: how to break up a monolith, manage inter-service communication, testing, deployment, and observability. The second edition is heavily updated. Read this before deciding to migrate to microservices.

Clean Architecture — Robert C. Martin

Covers the SOLID principles, component coupling, and how to design systems that can evolve. Often controversial, but its thinking is important to understand, even if you don’t agree with all its implementation recommendations.

Official Documentation #

Official documentation is the first source of truth, not Stack Overflow or blogs. Get into the habit of referring to it before searching elsewhere.

Development Tools #

IDEs #

IntelliJ IDEA is the best Java IDE today. The free Community version is already very feature-rich for most needs. The Ultimate version adds Spring support, in-IDE database tools, a profiler, and much more. Most professional Java developers use IntelliJ.

Visual Studio Code with the Java extensions (Microsoft’s Extension Pack for Java) is a lighter alternative. Suitable if you work with many languages and don’t want to switch IDEs. Its Java support isn’t as rich as IntelliJ’s, but it’s more than enough for most projects.

Eclipse is an older IDE still used mainly in enterprise companies that haven’t migrated. Not recommended for new projects unless the team requires it.

Build Tools #

Maven vs Gradle — When to Choose Which?

CHOOSE MAVEN WHEN:
  ✓ New Java teams — Maven's conventions are easier to learn
  ✓ Enterprise projects that need strong standardization
  ✓ The plugin ecosystem is already very mature

CHOOSE GRADLE WHEN:
  ✓ Build scripts need complex conditional logic
  ✓ Android development — Gradle is the default
  ✓ Build time is critical — Gradle's incremental builds are much faster
  ✓ Large multi-module projects

Code Quality Tools #

Checkstyle — checks code style (formatting, naming, line length). Configure it in Maven/Gradle and run it in the CI pipeline.

SpotBugs (the successor of FindBugs) — static analysis that detects potential bugs: null pointer dereferences, resource leaks, race conditions, and security issues before runtime.

SonarQube / SonarCloud — a comprehensive code quality analysis platform. It combines bug detection, code smells, vulnerabilities, and technical debt in one dashboard. SonarCloud is the cloud version for public repositories (free).

JaCoCo — measures code coverage for unit tests. Integrate it with Maven/Gradle and the CI pipeline to ensure your tests cover enough code.

Performance and Profiling Tools #

VisualVM — a free tool bundled with the JDK for monitoring heap, threads, CPU usage, and simple profiling. A good starting point before using paid tools.

Java Mission Control (JMC) — a more complete profiling and monitoring tool, based on Java Flight Recorder. Free since JDK 11.

async-profiler — a sampling profiler with very low overhead, suitable for production profiling. Produces flame graphs that are easy to interpret.

Arthas (from Alibaba) — a JVM diagnostic tool for production: decompile deployed classes, trace method calls, monitor threads, and much more — without restarting the application.

Databases and Migrations #

Flyway — a database schema migration tool with an SQL-first approach. Migrations are defined in versioned SQL files (V1__create_table.sql, V2__add_column.sql). Very simple and battle-tested in production.

Liquibase — a more flexible Flyway alternative. Supports YAML, XML, and SQL formats for defining schema changes. More powerful but more complex.

DBeaver — a universal database GUI supporting all popular databases (PostgreSQL, MySQL, Oracle, MongoDB, and others). Free and open source. Very useful for development and debugging.

Communities and Forums #

Stack Overflow — for specific technical questions. Tags java, spring-boot, hibernate, etc. Before asking, search first — your question has probably already been answered.

Baeldung (baeldung.com) — the most complete Java tutorial site. Short, to-the-point articles with runnable code examples. Very consistent quality. This is the first source to check after official documentation.

Reddit r/java — a Java discussion community, ecosystem news, and questions. More relaxed than Stack Overflow.

Dev.to — a developer blogging platform. Many high-quality Java articles from industry practitioners.

InfoQ Java (infoq.com/java) — news and in-depth articles about Java trends: the latest JEPs, conferences, architecture, and best practices from large companies.

Podcasts and Videos #

Podcasts #

Inside Java Podcast — the official podcast from Oracle’s Java team. Discusses JEPs, the latest Java features, and interviews with the people behind the JDK. Short episodes and very informative.

A Bootiful Podcast — hosted by Josh Long (Spring Developer Advocate). Weekly interviews with developers and thinkers in the Spring and Java ecosystems.

Java Pub House — discusses Java topics from basic to advanced in a relaxed, digestible format.

YouTube Channels #

Java (Oracle’s official channel) — presentations from JavaOne/Oracle DevLive, JEP overviews, and new feature tutorials.

Spring Developer — tutorials, webinars, and presentations from the Spring team. Highly recommended for Spring Boot developers.

Amigoscode — practical, easy-to-follow modern Java tutorials, including Spring Boot, microservices, and Docker.

Telusko — explains Java concepts from the basics with a very clear teaching style.

Advanced Topics to Explore #

After mastering the foundations, here are topics that will take you to the next level:

Concurrency and Reactive #

Project Loom — a JDK feature introducing Virtual Threads (Java 21+). Extremely lightweight threads that enable performant blocking concurrency models like async, without async programming complexity. This changes how you write concurrent code in Java.

Project Reactor and RxJava — reactive programming libraries for Java. Used by Spring WebFlux. Learn these if you’re building I/O-bound services that need very high throughput.

JVM Internals #

Understanding how the JVM works makes you a far better developer:

Important JVM topics to understand:
  ├── Class loading — how bytecode is loaded into memory
  ├── Memory model — heap, stack, metaspace, and GC roots
  ├── Garbage collection
  │   ├── G1GC (default Java 9+) — balanced throughput and pauses
  │   ├── ZGC (Java 15+) — pauses < 1ms, suitable for latency-sensitive apps
  │   └── Shenandoah — a low-pause alternative from Red Hat
  ├── JIT compilation — how bytecode is optimized into native code
  └── Java Flight Recorder — built-in profiling with minimal overhead

GraalVM — a Java runtime supporting native compilation (binaries without a JVM) and polyglot execution (running JavaScript, Python, Ruby from Java). Use Quarkus or Micronaut to take advantage of GraalVM native images.

Advanced Testing #

Testcontainers — a library for running real dependencies (PostgreSQL, Redis, Kafka, etc.) in Docker containers during integration tests. Eliminates the need for database mocks and produces far more realistic tests.

WireMock — a mock HTTP server for tests that depend on external APIs. You define the expected responses and WireMock simulates that server.

ArchUnit — tests that verify code architecture: ensure controllers don’t directly access repositories, certain packages don’t have circular dependencies, and naming conventions are followed.

Observability #

Production systems need to be observable. The three pillars of observability:

Logging    → Logback / Log4j2 + structured JSON logging
Metrics    → Micrometer + Prometheus + Grafana
Tracing    → OpenTelemetry + Jaeger / Zipkin

Micrometer — a metrics facade for Java, integrated directly with Spring Boot Actuator. Export to Prometheus, Datadog, CloudWatch, and dozens of other backends.

OpenTelemetry — the industry standard for distributed tracing. One instrumentation, many backends. Use it with Jaeger or Zipkin to trace requests across many microservices.

Security #

OWASP Java Security — OWASP provides Java-specific security cheat sheets that should always be your reference: SQL injection prevention, XSS, CSRF, authentication, and much more. Available free at cheatsheetseries.owasp.org.

Spring Security — the most comprehensive security framework for the Spring ecosystem. Supports OAuth2, JWT, SAML, and various authentication and authorization mechanisms.

Java Certifications #

Certifications aren’t a requirement, but they can be useful for formally proving competence — especially when applying for jobs at enterprise companies that value official credentials.

Oracle Certified Professional: Java SE Developer is the most recognized certification in the industry. It consists of two exams: Java Foundations (Associate) and Java SE Developer (Professional). The exams cover all aspects of the Java language including generics, collections, lambdas, streams, concurrency, and modules. The best practice material is available on the Enthuware site and the OCP Study Guide book by Scott Selikoff & Jeanne Boyarsky.

Spring Professional Certification from VMware (Broadcom) proves deep understanding of the Spring ecosystem: the IoC container, AOP, Spring MVC, Spring Data, Spring Security, and Spring Boot. Relevant for developers working in the Spring ecosystem who want differentiation.

Are certifications worth it? It depends on the context. In startups and tech companies, portfolios and open-source contributions are usually valued more. In consulting firms, government, or traditional enterprises, certifications are often a formal requirement.

Daily Habits That Shape a Good Developer #

Technical skills alone aren’t enough. The daily habits that separate an average developer from one who keeps growing:

Read more code than you write. The source code of Spring Boot, Guava, or popular open-source projects is the best teacher of idiomatic Java. GitHub is the largest code library that has ever existed — use it.

Write tests before you know the code runs. It’s not about dogmatic TDD, but about forcing yourself to think about interfaces and contracts before implementation. Tests written after the code tend to follow the implementation, not test it.

Commit small and often. Large commits make code review difficult and rollbacks harder when something goes wrong. One commit should represent one cohesive logical change.

Actively review other people’s code. Code review isn’t just for finding bugs — it’s the best way to learn different approaches and expose assumptions you’ve never questioned.

Document decisions, not implementations. Good code explains itself. What needs documenting is why a certain decision was made, not what the code does.

Reference Open-Source Projects and Repositories #

Studying large open-source project codebases is the best way to understand how senior engineers write and organize Java code at production scale.

Spring Framework (github.com/spring-projects/spring-framework) — a very well-structured codebase with high test coverage. How Spring implements the IoC container, AOP, and MVC is the best real-world example of design pattern usage.

Guava (github.com/google/guava) — a widely used utility library from Google. Guava’s code is a lesson in idiomatic Java, immutability, and good API design.

Apache Commons (commons.apache.org) — a collection of utility libraries tested for years in production. StringUtils, FileUtils, IOUtils, and many more — read their source code for inspiration.

Netty (github.com/netty/netty) — a high-performance asynchronous networking framework. Studying Netty teaches how Java handles I/O at a low level, pipeline patterns, and how to write efficient concurrent code.

Hibernate ORM (github.com/hibernate/hibernate-orm) — seeing how Hibernate implements dirty checking, session management, and query generation gives you deep insight into JPA that can’t be gained from reading documentation alone.

Recommended Articles and Blogs #

Several authors consistently produce high-quality Java content:

Martin Fowler (martinfowler.com) — author of Refactoring, PEAA, and many articles on software design, microservices, and agile. Every article is written with remarkable precision and depth.

Vlad Mihalcea (vladmihalcea.com) — a Hibernate and JPA specialist. His articles on the N+1 problem, connection pooling, and database performance tuning are the best references that exist on those topics.

Thorben Janssen (thorben-janssen.com) — very practical Hibernate and JPA tips and tricks. Focuses on the real problems developers face daily.

Eugen Paraschiv / Baeldung (baeldung.com) — mentioned above, but worth mentioning again. Consistent tutorials, always updated, covering almost every topic in the Java ecosystem.

Adam Bien (adam-bien.com) — a Jakarta EE developer advocate writing about enterprise Java, MicroProfile, and architecture. Known for his minimalist approach — “Real World Java EE Patterns”.

Conferences #

Attending conferences — even virtually — is the best way to learn about industry trends and learn from practitioners facing large-scale problems.

JavaOne / Oracle CloudWorld — Oracle’s official Java conference. Presentations from the JDK team, new feature announcements, and deep technical sessions.

Devoxx — Europe’s largest Java community conference. All presentations are available free on YouTube after the conference. Very high content quality.

Spring I/O — the annual Spring ecosystem conference in Barcelona. All presentations are available on YouTube.

QCon — a conference for senior software engineers from InfoQ. Covers architecture, engineering practices, and lessons from large companies. Expensive tickets but very high content quality.

JFokus — a Java conference in Stockholm with world-class speakers. Recordings are available on YouTube.

Learning Roadmap #

For developers just starting or wanting a structured approach to learning:

flowchart TD
    A["Java Foundations\nSyntax, OOP, Collections\nExceptions, Generics"] --> B["Modern Java\nStreams, Lambdas, Optional\nCompletableFuture, Records"]

    B --> C{Choose a path}

    C --> D["Backend Web\nSpring Boot\nREST APIs, JPA, Security"]
    C --> E["Enterprise\nJakarta EE\nCDI, JAX-RS, JPA"]
    C --> F["Cloud Native\nQuarkus / Micronaut\nNative Images, Kubernetes"]

    D --> G["Databases\nHibernate ORM\nFlyway / Liquibase"]
    E --> G
    F --> G

    G --> H["Messaging\nKafka / RabbitMQ\nEvent-driven architecture"]

    H --> I["Observability\nLogging, Metrics, Tracing\nOpenTelemetry"]

    I --> J["Architecture\nMicroservices\nDDD, CQRS, Event Sourcing"]

    J --> K["Advanced JVM\nPerformance, GC tuning\nProfiling, Virtual Threads"]

Each stage takes a different amount of time depending on previous experience. Don’t rush to the next stage before the foundations are truly solid — a shallow understanding of many topics is far less valuable than a deep understanding of a few key ones.

Summary #

• Read Effective Java before or alongside learning frameworks — it teaches how to use Java correctly, not just how to use it.
• Official documentation is always more accurate than third-party tutorials — get used to reading primary sources even if they’re heavier than blogs or Stack Overflow.
• Baeldung (baeldung.com) is the second most trusted source after official documentation for Spring, Hibernate, and Java topics in general.
• Testcontainers is one of the best investments for improving integration test quality — real dependencies in containers are far more accurate than mocks.
• Profile before optimizing — VisualVM or Java Mission Control before changing code. Optimization without data is guessing.
• Virtual Threads (Project Loom, Java 21+) change how concurrent code is written in Java — this is the biggest change to Java’s concurrency model in years.
• A roadmap isn’t a rigid sequence — exploring based on real project needs is far more effective than linear learning. Real problems are the best teachers.
• Communities are a long-term investment — be active on forums, read lots of other people’s code on GitHub, and don’t hesitate to share what you learn.

← Previous: Selenium   Next: Strings →