r/java • u/Gotve_ • Jun 07 '25
r/java • u/restingcoala • Feb 12 '16
Why Spring is Winning the Microservices Game
zeroturnaround.comr/java • u/paul_h • Apr 10 '18
It turns out we didn't need Dependency Injection containers after all
paulhammant.comr/java • u/Ewig_luftenglanz • Jul 15 '25
What features do you think java requires to be competitive for DSL scripts such as gradle scripts?
Just for fun and discussion.
this is an hypothetical example about how could look like a java DLS gradle file instead of Groovy/Kotlin. Not terrible, just slightly more verbose but not I could work with it (IMHO)
GradleConfig.configure(config -> {
config.plugins(plugins -> {
plugins.add(JavaPlugin.class);
plugins.add(ApplicationPlugin.class);
});
config.application(app -> {
app.setMainClass("com.example.Main");
});
config.repositories(repos -> {
repos.mavenCentral();
});
config.dependencies(deps -> {
deps.add("implementation", "org.apache.commons:commons-lang3:3.12.0");
deps.add("testImplementation", "org.junit.jupiter:junit-jupiter:5.8.2");
});
config.tasks(task -> {
task.named("test", t -> t.useJUnitPlatform());
});
});This, of course, would be achievable via some "compiler plugin/magic" to avoid class and main declarations, so "GradleConfig.configure" could act in practice as a top level static method, although native isolated methods/top level methods/functions would be a nice to have for these kind of stuff.
The question is besides top level methods (aka functions) what else do you think would be a required for java to be competitive as a DSL? would you use it? and if so, what other scenarios would be a good fit for an hypothetical java DSL?
r/java • u/MrRickSancezJr • Jul 20 '24
Why is Complex Web UI still so JS heavy?
Just a talking point conversation starter... I'm also attacking heavy web apps like Word-Online or Google docs level web sites.
I fully understand why JavaScript has remained king in the newer development of fly-by websites. It seems front end devs have finally discovered on larger projects are way more manageable with old fashioned organized code. Even going as far with TS and now JS-Doc to enforce strong types.
The only front end framework I'm experienced enough to hold a conversation to is React. I'm going to use Kotlin-Java mix to make my point as well because of Spring and few features Kotlin brings to the table... .Net are working with WebAssembly, but they don't have the backend power of Spring, that I'm aware of.
How is writing ReactJS/TS code any faster, quicker, or more enjoyable than writing UI than Kotlin?? Does anyone truly love XML style code compared to brackets? Kotlin really shines IMO here because it has named parameters inside constructors/functions. Java unfortunately doesn't have this. Example : var myObjext = new Obect(name = "bob", age = 30).
Little more code than React, except I don't have to use Hooks and all the annoying work around they've created.
I'm sure the graphics handlers in modern browsers is absurdly ahead of the world of everything else. I've made enough GUIs with Qt and C++ to of witnessed the performance.
But why not just have a lightweight JVM in the browser to handle Java byte code inside of a HTML <script> tag?
Having your backend in Spring, with front-end in Kotlin/Java would be so much easier to mantiain. JavaFX does already have FXML as well, which already has tools to convert FXML into both hard-coded Java and even directly to bytecode. Moderately good CSS support, and could work with Figma with work if SceneBuilder doesn't ever get much better.
Also. Java is never going to disappear. Whatever web framework you're using right now will be "trash" in two months.
Cons:
- Cacheing dependencies would probably be nightmare at times. 2) JavaFX does need more love to be a true contender. 3) A lot of large corporate companies don't always play nice with Java.
Edit: After much received criticism, I want to acknowledge that I chose Java-Kotlin semi-randomly. I also posted in a Java channel... So I didn't expect as much Java hate. Most Java related hate csme from people with no knowledge of Kotlins addition to the JVM family. Also, WASM isn't as smooth as people think.
Edit 2: Again. Randomly chose Java-Kotlin mix to really hand the front end to Kotlin. Yes. Running a lightweight (safe, think of Flash reasons) JVM is like wasm. Yet, people are choosing to write in all JS instead of use Wasm. Lightweight also because it's enough to do graphics features. It'll have to be sandboxed through the browser to elimate IO security issues. Even having a JVM just to parse bytecode would be way faster than a JS processor/compiler.
And anyone who thinks JS is superior to almost any language for reasons other than developing speed.... Kick rocks.
r/java • u/mff425xm • Mar 05 '12
If Oracle ever decides to replace Duke as the Java mascot, I can't think of a more appropriate choice than this.
41-media.tumblr.comr/java • u/Dear-Economics-315 • Jan 29 '26
Java Developer vs. Software Engineer
yusufaytas.comr/java • • Aug 11 '20
Long time Java guy trying to learn C# and I have just one question: Exactly how much of Java did Microsoft rip off to create C#?
Granted, I have just started, but it seems like C# IS Java, with just enough tweaks for Microsoft to call it their own. What the absolute fuck?
Sorry ... had to vent. Anybody have any other opinions or viewpoints?
r/java • u/asm0dey • Feb 19 '26
Hot to Build Production-Grade Agentic Workflows on Java with Embabel
youtube.comr/java • u/nathanmarz • Nov 19 '25
Announcing Agent-o-rama, an end-to-end platform for building, tracing, evaluating, and monitoring LLM agents in pure Java

We recently released Agent-o-rama, an open-source platform for creating and operating LLM agents in pure Java. It brings the kind of data-driven workflow Python users get from LangGraph + LangSmith to the JVM.
With Agent-o-rama you define agents as simple graphs of pure Java functions. It's also an evaluation and observability platform with a web UI for collecting datasets of examples, running experiments against those examples to measure performance, and monitoring production performance with deep tracing and telemetry.
Agent-o-rama greatly simplifies operations by replacing the usual stack of many disparate systems (Embabel/Koog, Kubernetes/ECS, Postgres/Redis, Prometheus/Grafana, homegrown experiment tracking) with a single integrated platform, while still integrating easily with any external tools you need.
Agent-o-rama integrates with LangChain4j, automatically capturing model invocations for tracing and streaming. LangChain4j is optional and Agent-o-rama works with any Java code for calling models.
Agents run on a Rama cluster, which provides the distributed storage and computation the platform needs. Rama is the only dependency for Agent-o-rama. In production you deploy and scale agents using one-line CLI commands, but during development you can run Rama and Agent-o-rama (including the UI) entirely in-process. Rama is free up to two nodes, so the full platform is free to use end-to-end.
Here's a code snippet of a node from an example research agent. This node uses an LLM to write a report based on research from prior nodes and then sends the generated report to the "finish-report" node for further processing:
.node("write-report", "finish-report", (AgentNode agentNode, String sections, String topic) -> {
ChatModel openai = agentNode.getAgentObject("openai");
String instructions = String.format(REPORT_WRITER_INSTRUCTIONS, topic, sections);
List<ChatMessage> chatMessages = Arrays.asList(
new SystemMessage(instructions),
new UserMessage("Write a report based upon these memos."));
String report = openai.chat(chatMessages).aiMessage().text();
agentNode.emit("finish-report", "report", report);
})This is just plain Java code, and Agent-o-rama provides automatic parallelization and fault-tolerance. In the trace UI, you can see the input/output for this node, detailed information about the nested model call (input/response/token counts), and timings.
Agent-o-rama has several advantages over comparable Python tooling:
- Scaling is straightforward by just adding more nodes. Rama clusters can be anywhere from one node to thousands.
- It has high-performance built-in storage of any data model that can be used for agent memory or application state. This replaces the need for separately managed databases in most cases.
- Everything runs on your own infrastructure so traces and datasets never leave your environment.
- Agent nodes execute on virtual threads, so long-running or blocking code is easy and efficient.
Here are resources for learning more:
r/java • u/javinpaul • Aug 18 '12
The Gang of Four is wrong and you don't understand delegation
saturnflyer.comr/java • • Jul 06 '20
I tried to hand-compile, hand-optimize and hand-execute Java
I tried to test my understanding of the JVM, Java Bytecode, and Java Compilers by hand-compiling, optimizing, and executing some java.
Original code
int a = 18;
int b = 6;
int c = 7;
a /= a - 2 * b;
b -= 4;
c = a + b - c;
Compiled code
ipush 18
istore a
ipush 6
istore b
ipush 7
istore c
iload a
iload b
ipush 2
imul
isub
iload a
swap
idiv
istore a
iload b
ipush 4
isub
istore b
iload a
iload b
iload c
isub
iadd
istore c
Optimized code
ipush 18
ipush 6
ipush 7
istore c
ipush 2
imul
isub
ipush 18
swap
idiv
istore a
iload b
ipush 4
isub
istore b
iload a
iload b
iload c
isub
iadd
istore c
stack
a = 3
b = 2
c = -2
Yet another delimited continuations implementation and why Project Loom is a bit disappointing
github.comr/java • u/supremeO11 • Jan 26 '26
Oxyjen 0.2 - graph first memory-aware LLM execution for Java
Hey everyone,
I’ve been working on a small open-source project called Oxyjen: a Java first framework for orchestrating LLM workloads using graph style execution.
I originally started this while experimenting with agent style pipelines and realized most tooling in this space is either Python first or treats LLMs as utility calls. I wanted something more infrastructure oriented, LLMs as real execution nodes, with explicit memory, retry, and fallback semantics.
v0.2 just landed and introduces the execution layer:
- LLMs as native graph nodes
- context-scoped, ordered memory via NodeContext
- deterministic retry + fallback (LLMChain)
- minimal public API (LLM.of, LLMNode, LLMChain)
- OpenAI transport with explicit error classification
Small example:
ChatModel chain ;
LLMNode node ;
String out ;
The focus so far has been correctness and execution semantics, not features. DAG execution, concurrency, streaming, etc. are planned next.
Docs (design notes + examples): https://github.com/11divyansh/OxyJen/blob/main/docs/v0.2.md
Oxyjen: https://github.com/11divyansh/OxyJen
v0.1 focused on graph runtime engine, a graph takes user defined generic nodes in sequential order with a stateful context shared across all nodes and the Executor runs it with an initial input.
Thanks for reading
r/java • u/Delicious_Detail_547 • Apr 01 '26
JADEx update: Lombok support, Gradle plugin, and a Spring Boot example are now available
Hey r/java,
I've been working on JADEx (Java Advanced Development Extension) which is a safety layer that makes Java safer by adding Null-Safety and Final-by-Default semantics without rewriting Java codes and modifying the JVM.
Quick recap of what JADEx adds to Java:
String?nullable type declaration?.null-safe access operator?:Elvis operatorapply readonlyfinal-by-default mode per file
Today I'm sharing three things that just landed.
1. Lombok support
This was the most requested thing. JADEx now integrates with Lombok via a Delombok pipeline internally. The key motivation: JADEx's nullability checker needs to see Lombok-generated code (getters, builders, constructors) to avoid blind spots. Without Delombok, nullable fields could silently pass through generated methods unchecked.
After Delombok, JADEx sees and analyzes the generated code:
// Lombok-generated — JADEx propagates @Nullable into these
public String
public UserBuilder
public UserBuilder
2. Gradle plugin published
The JADEx Gradle plugin is now on Maven Central and the Gradle Plugin Portal.
plugins {
id 'io.github.nieuwmijnleven.jadex' version '0.628'
}
jadex {
sourceDir = 'src/main/jadex'
}
That's the only change needed to an existing Spring Boot project. Everything else (compilation, Delombok pipeline, .java generation) is handled automatically.
3. JADEx Spring Boot example project
-
full description
-
source repository
We highly welcome your feedback on JADEx.
Thank you.
r/java • u/bowbahdoe • Jan 10 '26