JetBrains’ Post

Great to see this evolution in the agent ecosystem. Standardization layers like ACP can do for AI agents what LSP did for languages—unlock true interoperability across IDEs. For Java developers, this is a strong step toward building context-aware, portable agents without being tied to a single toolchain. Looking forward to how this shapes developer productivity and workflows going forward. #Java #AI #Agents #DeveloperTools #Innovation #SoftwareEngineering

I’ve had my eye on ACP, but for lack of a Java SDK, it wasn’t high on my list of things to look into. Mark seems to have changed that by creating a Java SDK for ACP. I’ll definitely have a look at this.

Using GitHub Copilot to generate your Java code? Here's a full comparison, with details and advices, on the best approaches: https://lnkd.in/e48uhQDh Feedback is highly welcome!!

Discover how method overloading in Java enables flexible code by allowing multiple methods with the same name but different parameters.

💡 Most Java developers still think thread creation is just: new Thread().start(); But that mindset is already outdated. Java has quietly evolved… and with Virtual Threads (Project Loom), the entire concurrency model has changed 🚀 Here’s the real shift: 👉 Traditional Threads → Heavy, 1:1 OS mapping 👉 ExecutorService → Controlled, pooled execution 👉 Virtual Threads → Lightweight, scalable, millions possible 🔥 And the most powerful pattern today? 👉 Executors.newVirtualThreadPerTaskExecutor() You get: ✔ Clean architecture (task vs execution separation) ✔ Massive scalability ✔ Simple, readable code ✔ No thread pool tuning headaches 🧠 The biggest mindset change? 👉 Don’t change your business logic 👉 Just change how it executes Same Runnable. Different execution model. That’s how modern Java systems are built. 📌 I’ve broken this down with: ✔ Complete runnable examples ✔ Traditional vs Executor vs Virtual Threads ✔ Internal working (what JVM actually does) ✔ Real-world scenarios & pitfalls 👇 Read here: https://lnkd.in/e-vdH8Vc ⚠️ If you're building backend systems and not using virtual threads yet… you’re leaving serious performance on the table. #Java #VirtualThreads #ProjectLoom #Concurrency #BackendDevelopment #Multithreading

Continuing my OOPS journey by understanding Access Modifiers in Java, which play a key role in controlling visibility and security of code. Access Modifiers in Java define where a class, variable, method, or constructor can be accessed from. They are essential for implementing encapsulation and maintaining proper control over data in an application. Java provides four types of access modifiers: 🔷 1️⃣ Private Accessible only within the same class Provides the highest level of data hiding Commonly used for variables 🔷 2️⃣ Default (No Modifier) Accessible within the same package Not accessible outside the package Useful for internal project-level access 🔷 3️⃣ Protected Accessible within the same package Also accessible in subclasses (even in different packages) Useful in inheritance scenarios 🔷 4️⃣ Public Accessible from anywhere in the program No access restrictions Used for methods or classes that need global access 📌Why Access Modifiers Are Important? Help achieve data hiding and encapsulation Improve security of applications Control unwanted access to variables and methods Make code more structured and maintainable Essential for designing large-scale and secure systems Access modifiers are widely used in real-world Java applications and frameworks, especially in backend development where controlling access to data is critical. Understanding them clearly helps in writing clean, secure, and professional code. #java #JavaDeveloper #learning #BackendDeveloper #backend #motivation #consistancy

Java is evolving fast… but if we talk about concurrency in production today, the picture is more nuanced. Here’s the reality - Java: • Virtual Threads (stable) - simplify writing concurrent code   • CompletableFuture - powerful, but complex and harder to maintain   • Structured Concurrency - still in preview, not production-ready  Kotlin: • Coroutines - lightweight and easy to reason about   • Structured concurrency - built-in and mature   • Cancellation & error handling - consistent by design  The key difference isn’t syntax. It’s structure. In Java today, you can write concurrent code that works well.   In Kotlin, you get a complete model for managing concurrency safely. That difference shows up in real systems: • Less accidental complexity   • Better error propagation   • Easier long-term maintenance  My take: Java is clearly moving in the right direction (Loom is a huge step).   But today, Kotlin provides a more complete concurrency model for production use. If you care about writing concurrent code that stays readable and maintainable over time, the structure you choose matters more than the syntax.

📘 Day 34 – Java Concepts: Access Modifiers & Method Overriding Today I revised some important Java concepts that help in writing secure and flexible code. 🔹 Access Modifiers in Java Access modifiers define the visibility of classes, methods, and variables. • public – Accessible from anywhere • protected – Accessible within the same package and subclasses • default – Accessible only within the same package • private – Accessible only within the same class 📊 Accessibility (Summary): ✔ Inside class → All accessible ✔ Same package → public, protected, default ✔ Subclass (different package) → public, protected ✔ Outside package → only public 🔹 Rules of Method Overriding • Method name must be the same • Parameters must be the same • Return type must be same or covariant • Access modifier cannot be more restrictive 🔹 Covariant Return Type A child class method can return a subtype of the parent method’s return type. 🔹 Final Keyword • final variable → constant • final method → cannot be overridden • final class → cannot be inherited 💡 Understanding these concepts improves code reusability, security, and maintainability. #Java #OOP #Programming #CodingJourney #Day34 #Developers

Modern Java quietly made the Visitor pattern relevant again. Sealed classes changed the tradeoffs. It might be time to revisit Visitor. I wrote about why Visitor still makes sense if you're using Java 17–20: https://lnkd.in/dPkpgqtb