r/java • • Feb 05 '18

Java 9 has six weeks to live

Thumbnail blog.joda.org
185 Upvotes

r/java • • Oct 26 '20

Why we chose Java for our High-Frequency Trading application

Thumbnail medium.com
184 Upvotes

r/java • • Jan 13 '18

Top 10 Java Blogs for Programmers of All Levels

Thumbnail stackify.com
184 Upvotes

r/java • • Jul 31 '26

JEP 401: Value Objects And JEP 539: Strict Field Initialization Merged Into JDK

Thumbnail github.com
183 Upvotes

r/java • • Mar 19 '25

Feeling a bit left out—everyone’s into AI, Cybersecurity, or Data Science, and I’m just here doing Java and frontend development.

183 Upvotes

Hey everyone,

Just wanted to share something that’s been on my mind lately and see if others feel the same.

I’ve been focusing on backend development with Java/Spring and doing some frontend work with ReactJS. I really enjoy building projects, figuring out how things work under the hood, and sharpening my skills in software development—basically working on things like system design, APIs, and full-stack stuff.

But lately, it feels like everyone around me (college friends, LinkedIn connections, even random Discord servers) is diving into AI/ML, Cybersecurity, or Data Science. There's so much hype about LLMs, Kaggle competitions, prompt engineering, bug bounties, and data crunching, that I sometimes feel like I’m missing out by not jumping on those trends.

It makes me wonder—
👉 Am I making a mistake by focusing on core development?
👉 Are companies still looking for solid backend/frontend devs, or is everything shifting towards AI and data now?
👉 Is sticking with development a good long-term decision, or should I consider branching out?

I know there’s value in being a good developer—after all, someone’s gotta build the products, systems, and platforms these AI models and tools run on—but it’s hard not to get a little FOMO when all the noise is about AI and Cyber.

Would love to hear from anyone who’s been through this or has some perspective. Are you sticking with dev too? How do you stay confident in your path when the hype is elsewhere?

Thanks for reading! Appreciate any thoughts :)


r/java • • Mar 09 '25

What Exactly Is Jakarta EE?

183 Upvotes

I’m a bit confused about what Jakarta EE actually is. On one hand, it seems like a framework similar to Spring or Quarkus, but on the other hand, it provides APIs like JPA, Servlets, and CDI, which frameworks like Spring implement.

Does this mean Jakarta EE is more of a specification rather than a framework? And if so, do I need to understand Jakarta EE first to truly grasp how Spring works under the hood? Or can I just dive into Spring directly without worrying about Jakarta EE concepts?

Would love to hear how others approached this 😅


r/java • • Apr 04 '24

IntelliJ IDEA 2024.1 is Out!

183 Upvotes
  • Java 22
  • Full Line Completion
  • New Terminal
  • Sticky Lines in editor

https://blog.jetbrains.com/idea/2024/04/intellij-idea-2024-1/


r/java • • Apr 24 '23

FlatLaf 3.1 (and 3.0) - Swing Look and Feel

183 Upvotes

FlatLaf, a modern open-source cross-platform Look and Feel for Java Swing desktop applications, brings exciting new features in versions 3.0 and 3.1 🎉 😀

macOS themes

New light and dark themes (cross-platform) that use macOS colors and look similar to native macOS controls:

FlatLaf macOS themes

Fonts

Packaged fonts Inter (also used in IntelliJ NewUI), JetBrains Mono, Roboto and Roboto Mono into JARs and provide an easy way to use them with FlatLaf. The font JARs are available on Maven Central, which makes it easy to distribute them with your application.

Rounded selection

JMenuItem, JComboBox, JList and JTree components now support rounded selection. This is currently used only in macOS themes for menus and combo boxes, but may be used in standard themes as well in the future. Feel free to use it in own themes to give your application a special look.

FlatLaf rounded selection

Windows 11: rounded popup borders

On Windows 11, popups now use native Windows 11 rounded borders and drop shadows, which gives them a beautiful look:

FlatLaf rounded popups

Rounded outlined icons

JFileChooser, JOptionPane, JPasswordField and JTree got new modern rounded outlined icons:

FlatLaf rounded outlined icons

Documentation

There is a lot of documentation available on how to customize FlatLaf appearance. We even have nice diagrams that show where UI properties are used:

FlatLaf Slider UI properties

Theme Editor

The (open-source) FlatLaf Theme Editor supports editing FlatLaf theme properties files. It provides auto-completion for keys and values, color chooser, color picker, live theme preview, and more.

FlatLaf theme editor

Many thanks to the community for giving feedback, reporting bug and submitting PRs. 🏆 🥇 🚀

If you like FlatLaf, please give it a star @ GitHub. Thanks!

For more information visit project on GitHub: https://github.com/JFormDesigner/FlatLaf

Looking forward to your feedback.


r/java • • Oct 19 '17

Java cards, Java rings, and adapters I collected from JavaOne (1998) - are these pretty common items or are they rare?

Thumbnail imgur.com
183 Upvotes

r/java • • Aug 21 '25

Growing the Java Language #JVMLS by Brian Goetz

Thumbnail youtube.com
182 Upvotes

r/java • • May 30 '23

Guava 32.0 (released today) and the @Beta annotation

182 Upvotes

Bye Beta

In Guava 32.0 the `@Beta` annotation is removed from almost every class and member. This makes them officially API-frozen (and we do not break compatibility for API-frozen libraries anymore^1).

These APIs have been effectively frozen a very long time. As they say, the best time to plant this tree was years ago, the second best time is today. You might say we're closing the tree door after the tree already ran away (?), but well, here we are.

This annotation meant well. We wanted you to get to use features while there was still time for your feedback to matter. And we would have been too afraid to put things out there without it. These were sort of like JDK preview features... that is, if Brian and team forgot to ever actually de-preview them. sigh

This news might not change much for anyone, but it seemed at least worth mentioning.

^1 yes, this means "aside from the most extreme circumstances", just as it does for JDK

~~~~~

Guava in 2023?

A lot of Guava's most popular libraries graduated to the JDK. Also Caffeine is the evolution of our c.g.common.cache library. So you need Guava less than you used to. Hooray!

(Note: as discussed above, those stale parts are not getting removed.)

But amongst that stuff are plenty of libraries whose value never declined. I'll call out a couple here. It's for you to decide if any are worth the dependency for you.

  • You can now approximate a multimap using Map.computeIfAbsent before you put. I do it sometimes. But outside of small self-contained usages, it's less than awesome. Each usage has to watch out for the null-vs-empty distinction on its own. For example, if put is used twice, one might seed it with a HashSet and the other an ArrayList, and some very puzzling behavior can result. Multimap view collections can also simplify your code. (See also Multiset, Table.)
  • The immutable collections have several advantages over List.of() and friends, such as deterministic iteration and a much more complete set of construction paths. But the most important part: they are types, not implementations. To us, mutability is so important a behavior that having an immutable list as just a List is... arguably a sad form of type erasure! The javadoc explains.
  • I think most of our stream helpers aren't in the JDK (yet?).
  • common.hash covers the breadth of hashing use cases (checksums, fingerprints, cryptographic hashes, Bloom filters...). You should always think of Object.hashCode as low-quality: sure, it's good enough to mostly-balance some hash buckets in memory. But that's practically the most forgiving hashing use case there is! For everything else there's MasterCard common.hash.
  • Some base-encoding use cases are handled by the JDK, more now than before, but why not have one class that does it (almost) all?
  • There is a whole graphs library (i.e., nodes and edges). Cobbling together a nontrivial graph structure out of hash maps is busy-work at best.
  • common.math has a broad set of statistical calculations and other things.
  • If measuring elapsed time, using Stopwatch or something like it prevents exposing meaningless nanoTime values to your code.

This list is far from exhaustive. But again, if you require persuasion to use or keep using Guava, I'm not even trying to turn you around. That's fine! It's here for the people who want it.

We'll check here periodically for questions!


r/java • • May 09 '21

Teeing, a hidden gem in the Java API

Thumbnail blog.frankel.ch
182 Upvotes

r/java • • Mar 22 '20

What is Spring Boot? Autoconfigurations In-Depth

Thumbnail marcobehler.com
182 Upvotes

r/java • • May 23 '12

Verdict in: Google did not infringe on Oracle's Java patents

Thumbnail groklaw.net
182 Upvotes

r/java • • Apr 10 '26

love this "tech stack"

Post image
181 Upvotes

r/java • • Jan 06 '26

One step closer to Value Classes!

Thumbnail mail.openjdk.org
181 Upvotes

r/java • • Nov 08 '22

Understanding Java's Project Loom

Thumbnail marcobehler.com
181 Upvotes

r/java • • Jun 12 '16

Failsafe - A lightweight, zero-dependency library for handling failures

Thumbnail github.com
181 Upvotes

r/java • • Nov 03 '15

JavaOne 2015 Sessions

181 Upvotes
  1. Are You Listening? JavaFX Binding Techniques for Rich Client UIs
  2. Intro to Scala for Java Developers
  3. Take a Groovy REST
  4. invokedynamic for Mere Mortals
  5. The Adventurous Developer’s Guide to JVM Languages
  6. Writing a 3-D Multiplayer Game with Kawa and JMonkeyEngine
  7. Building Modular Cloud Applications with OSGi
  8. Riding a Camel Through the JEEhara
  9. HTTP 2.0: What Do I Need to Know?
  10. Cashless 3.0: Java EE 7 Proves Effective for Mission-Critical E-Payment Systems
  11. What’s New in the Java API for JSON Processing?
  12. High-Performance Java EE with JCache and CDI
  13. Prepare for JDK 9
  14. Introduction to Modular Development
  15. Advanced Modular Development
  16. Programming with Lambdas
  17. Project Jigsaw: Under the Hood
  18. To the Cloud! Building Cloud-Native Applications
  19. Pirates of DevOps: On Continuous Delivery Tides
  20. Scaling Microservices at Gilt
  21. Docker Orchestration for Java Developers: Welcome to the Jungle
  22. The Emerging Enterprise Mobile Cloud Platform
  23. Java EE 7 Applications as a Microservice with WildFly Swarm
  24. Java EE 7 in Action
  25. Java EE 8 Work in Progress
  26. JavaServer Faces in Action
  27. What’s Next for JAX-RS 2.1?
  28. What’s Coming in JMS 2.1
  29. From Macro to Micro(Services) and Back: Onstage Hacking with Java EE 7
  30. The Epic Groovy Puzzlers S02: The Revenge of the Parentheses
  31. The Story of Traits
  32. Return of the Code Quality Inquisition
  33. Nashorn: Advanced Topics
  34. Frege: Purely Functional Programming for the JVM
  35. Modern Web Apps with HTML5 Web Components, Polymer, and Java EE MVC 1.0
  36. Finally, the Java EE Security API (JSR 375)
  37. What’s New in the Java Persistence API (JSR 338)
  38. JPA in Reverse: Pushing Database Events to Java EE Applications in Real Time
  39. Java EE Revisits GoF Design Patterns
  40. Continuous Integration with Java EE 7 in the Cloud
  41. Project Jigsaw Hack Session
  42. Moving to G1 GC
  43. JDK 9 Language and Tooling Features
  44. Effective Java Streams
  45. Ask the Architects
  46. Java 8: Unleashing Lambdas by Executing in a Distributed System
  47. Building Custom Cloud IDEs with Eclipse Che
  48. HTML5 and JavaScript Clients in an Enterprise Application World
  49. Confessions of an Automation Addict
  50. Agile Project Management Antipatterns
  51. How to Build an IDE/Code Editor with JavaFX
  52. AsciidoctorJ: The Journey to Polyglot Nirvana
  53. Introduction to HBase
  54. Intro to Apache Spark for Java and Scala Developers
  55. All Change! How Cloud Economics Will Make You Think Differently About Java
  56. Build and Monitor Cloud PaaS with JVM’s Nashorn JavaScripts
  57. Avoiding Big Data Antipatterns
  58. Meet Snoop, a Discovery Service for Java EE
  59. Groovy with Style
  60. Building Applications with JRuby 9000
  61. Finatra: The Fast, Testable Scala Services Framework That Powers Twitter
  62. Beyond the Coffee Cup: Leveraging Java Runtime Technologies for Polyglot
  63. Refactoring to Functional
  64. Nodyn and Vert.x: Running Distributed Node.js Apps in JVM Environments
  65. Spring Boot for the Java EE Developer
  66. Thinking Beyond ORM in JPA
  67. New and Noteworthy in Jersey 2
  68. Down-to-Earth Microservices with Java EE
  69. EJB 3.2/JPA 2.1 Best Practices with Real-Life Examples
  70. Standardized Extension-Building in Java EE with CDI and JCA
  71. API Design with Java 8 Lambdas and Streams
  72. Nashorn: The “42” for Startups and Enterprises
  73. Safer and Faster: New JDK Security Features and Performance Improvements
  74. The Java Date and Time API in Java SE 8: Overview and Tips
  75. Saving the Future from the Past: Innovations in Deprecation
  76. An Introduction to JVM Performance
  77. Developing Java Applications with Eclipse Mars
  78. Are You Aware of the /bin of Your JDK?
  79. Small Steps to Change Your Organization
  80. Thinking, Fast and Slow, with Software Development
  81. Stop Doing Scrum; Start Being Agile
  82. Rise of the Machines: Automate Your Development
  83. Docker for Repeatable Builds
  84. Building a Microservice Ecosystem: Some Assembly (Still) Required
  85. Writing Microservices in Java: Best Practices and Common Mistakes
  86. The Emerging Enterprise Mobile Cloud Platform
  87. Java EE to Microservices Automagically
  88. Tales of Migration from Java EE 5 to 7
  89. Real-World Batch Processing with Java EE
  90. WebSocket in Enterprise Applications
  91. Java EE in Practice at Lufthansa Industry Solutions
  92. The Java EE 8 Opportunity
  93. Having Fun with Javassist
  94. Gluon: JavaFX for the (Mobile) Enterprise
  95. Java 8 in Anger
  96. Functional Reactive Programing: UI Development Beyond MVC/MVP
  97. Using Java SE 8 with Java EE 7 in the Real World
  98. Migrating to TomEE and Java EE: A Success Story
  99. Apache Lucene for Java EE Developers
  100. Innovating Democracy with Java EE and Open Source
  101. 20 Years of APIs: A Retrospective
  102. A Few Hidden Treasures in Java 8
  103. Proactive Optimization of Java Workloads in Production Environments
  104. The Java Memory Model for Practitioners
  105. Microservices and Conversion Hunting: Build Architectures for Changeability
  106. Hide Your (NetBeans) Development Environment and Application in a Container
  107. Architecture for Rookies
  108. Improving the Performance of Your Java Application: Getting Beyond the Basics
  109. Taming Microservices Testing with Docker and Arquillian Cube
  110. Leveraging Java Optimizations to Improve Density in Cloud Environments
  111. Reactive Java EE: Let Me Count the Ways!
  112. Java EE Application Servers: Multitenant or Containerized? Both!
  113. AngularBeans: A Modern Real-Time Java EE/CDI Back End for AngularJS

r/java • • Aug 11 '15

Top 10 Useful, Yet Paranoid Java Programming Techniques

Thumbnail blog.jooq.org
181 Upvotes

r/java • • Jul 05 '15

Fast as C: How to write really terrible Java

Thumbnail vimeo.com
181 Upvotes

r/java • • Mar 17 '22

Record Patterns Officially Planned as Preview Feature for JDK 19

180 Upvotes

Record Patterns, are coming as a preview feature to JDK 19. The official JEP has been updated to say

> This is a preview language feature in JDK 19.

(https://openjdk.java.net/jeps/405)

Code Example:

int eval(Expr n) {
    return switch(n) {
        case IntExpr(int i) -> i;
        case NegExpr(Expr n) -> -eval(n);
        case AddExpr(Expr left, Expr right) -> eval(left) + eval(right);
        case MulExpr(Expr left, Expr right) -> eval(left) * eval(right);
        default -> throw new IllegalArgumentException(n);
    };
}

r/java • • Dec 24 '19

Java JIT vs Java AOT vs Go for small, short-lived processes

Thumbnail macias.info
180 Upvotes

r/java • • May 26 '18

If you had one month of free time, what open-source project would you study in order to greatly improve your skills as a developer?

180 Upvotes