Embabel binaries now in Maven Central. How to use.

Guillaume Laforge has published the definitive bundle on writing AI agents in Java using the Agent Development Kit(ADK). It includes: 📊 a presentation 📹 a video recording 💻 code samples 📄 a codelab and an updated template project. Check out the blog: https://lnkd.in/dGXZJQHz that helps you navigate this super bundle. #Google #ADK #Java #AgentDevelopmentKit

🔥 𝗝𝗮𝘃𝗮 𝗦𝘁𝗿𝗲𝗮𝗺 𝗔𝗣𝗜: 𝗧𝗵𝗲 “𝗔𝗵𝗮!” 𝗠𝗼𝗺𝗲𝗻𝘁 𝗘𝘃𝗲𝗿𝘆 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗡𝗲𝗲𝗱𝘀 Most of us start with traditional 𝗳𝗼𝗿-𝗹𝗼𝗼𝗽𝘀, and honestly—they work. But the moment you understand 𝗦𝘁𝗿𝗲𝗮𝗺 𝗔𝗣𝗜, something clicks. Suddenly your code becomes more expressive, cleaner, and more intentional. In my latest video, I break down Stream API from scratch — not just the syntax, but the why behind it. Here’s what we explore: 🔹 Why Stream doesn’t modify your original list 🔹 Why a Stream can only be used once (like flowing water) 🔹 How filter() creates a new Stream 🔹 How map() transforms values 🔹 How reduce() gives you that final meaningful result 🔹 And how all of this forms a powerful pipeline: stream → filter → map → reduce To make it relatable, I also connect Streams with real-world data processing and Big Data concepts. Once you understand how these pieces fit, you will start preferring Stream API over loops—every single time. If you're learning Java, or want to write more elegant, functional-style code, this video will help you level up. 📽️ 𝗪𝗮𝘁𝗰𝗵 𝘁𝗵𝗲 𝗳𝘂𝗹𝗹 𝗯𝗿𝗲𝗮𝗸𝗱𝗼𝘄𝗻 𝗵𝗲𝗿𝗲: https://lnkd.in/g6am8Rwv

Just published today: a practical guide to Java Streams—creating from collections, lazy vs. terminal ops, map vs. flatMap, collectors (toList, groupingBy, joining), optional chaining, and when not to use streams. https://lnkd.in/d9gdZFht

Java Agents and Bytecode Manipulation: Practical Insights for Observability and Control 💡 Java agents are tiny programs that ride along the JVM, shaping how your code runs by touching bytecode as it’s loaded. They hook into the Instrumentation API via premain or agentmain, and they can add a bytecode transformer that rewrites methods on the fly or even redefines already‑loaded classes. 🧰 The core power lies in dynamic observability and behavior enhancement: you can inject timing data, log calls, or enforce constraints without changing your source. Libraries like ByteBuddy provide a safer, expressive way to describe transformations and minimize boilerplate. ⚠️ But there are trade‑offs: instrumentation adds overhead and can complicate debugging if not done carefully. Class‑loading boundaries, security policies, and startup sequencing can limit what you can safely modify in production. Start with targeted transforms and rigorous validation. 🚀 Real‑world patterns include profiling, tracing, and feature toggles. Keep transforms opt‑in and modular; prefer pre‑main agents when you need early instrumentation, and avoid sweeping changes that affect all classes. 🎯 Takeaways: align your goals, measure impact, and keep changes isolated. Pilot in staging, use feature flags, and document governance around live instrumentation. What’s your take? In what scenario would you consider using a Java agent, and what guardrails would you put in place? #Java #Bytecode #InstrumentationAPI #SoftwareEngineering #Observability

🚀 𝗦𝘁𝗼𝗽 𝗝𝘂𝗴𝗴𝗹𝗶𝗻𝗴 𝗜𝗻𝗱𝗲𝘅𝗲𝘀 — 𝗚𝗶𝘃𝗲 𝗠𝗲𝗮𝗻𝗶𝗻𝗴 𝘁𝗼 𝗬𝗼𝘂𝗿 𝗗𝗮𝘁𝗮 𝘄𝗶𝘁𝗵 𝗝𝗮𝘃𝗮 𝗠𝗮𝗽! Ever wished you could replace confusing index numbers with real names? That’s exactly what 𝗠𝗮𝗽 does in Java! 🔑 After working with 𝗟𝗶𝘀𝘁 and 𝗦𝗲𝘁, it’s time to explore something even more powerful — Map, the collection that connects your data like a phonebook. Instead of numeric indexes, it uses key-value pairs — so every key has a purpose, and every value has context. In my latest YouTube video, I’ve broken down 👇 ✅ What is a Map in Java and why it’s not part of the Collection interface ✅ Difference between List, Set, and Map ✅ How HashMap and Hashtable work internally ✅ Why keys are unique and how to iterate using keySet() ✅ When to use HashMap vs Hashtable (and what “synchronized” actually means) 💡 𝗜𝗳 𝗟𝗶𝘀𝘁 𝗶𝘀 𝗮𝗯𝗼𝘂𝘁 𝗼𝗿𝗱𝗲𝗿, 𝗮𝗻𝗱 𝗦𝗲𝘁 𝗶𝘀 𝗮𝗯𝗼𝘂𝘁 𝘂𝗻𝗶𝗾𝘂𝗲𝗻𝗲𝘀𝘀 — 𝗠𝗮𝗽 𝗶𝘀 𝗮𝗯𝗼𝘂𝘁 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀𝗵𝗶𝗽𝘀. And once you understand that, working with Java data structures becomes a lot more intuitive. 🎥 Watch the full video here 👉 https://lnkd.in/gPnvzg6B

#SpringBoot #Java #BackendDevelopment #API #Programming Post 2: The Backend #2 The Backend Engine Room: Building Industrial-Strength APIs The backend is the brain of your application. Here, we craft robust, secure, and maintainable engines. 🛠️ Spring Framework 6+ (Your Arsenal): · Spring Boot: Create production-ready apps with embedded Tomcat. · Spring Data JPA: Reduce boilerplate code by 90% with Hibernate. · Spring Security: Implement JWT-based auth. Security is a culture, not a feature. · Spring MVC: Master the web request lifecycle. 🌐 RESTful API Design (The Contract): Design stateless,intuitive APIs. Use correct HTTP status codes and document everything with OpenAPI (Swagger). 🛡️ The Testing Shield: Embrace Test-Driven Development(TDD) with JUnit 5 & Mockito. A tested codebase is a maintainable codebase. Master this layer to build reliable business platforms, not just features. #SpringBoot #Java #BackendDevelopment #API #Programming

Everything you need to know on building #Agents with #ADK and #Java in one guide by Guillaume Laforge Check it out 👇

The goal of Arconia OpenTelemetry is to provide a single dependency you can add to your Spring Boot application to get unified Java observability with minimal configuration and maximum compatibility with both OpenTelemetry and Micrometer ecosystems. #Java #SpringBoot #OpenTelemetry #Micrometer #Observability https://lnkd.in/drZ2mkvM

👉Concept Overview Exception handling becomes more powerful when we combine Custom Exceptions, throw, and throws. Custom exceptions help us represent business-specific errors, while throw and throws decide how and where exceptions should be handled. ✨ Custom Exceptions in Java X Custom exceptions are user-defined exception classes that extend Exception or RuntimeException. They allow developers to represent meaningful, domain-specific problems instead of relying only on built-in exceptions. Why Custom Exceptions Are Important Clear and meaningful error messages Example: Invalid ScoreException, InsufficientBalanceException. Better business logic validation Helps enforce rules like age limits, score limits, login validation, etc. Improved readability and debugging The name of the exception itself explains the cause of the error. Cleaner separation of errors System errors vs business validation errors become easy to understand. program. Often used with custom exceptions to trigger specific business-rule violations. Used inside methods and blocks Throws one exception at a time Happens at runtime Example use: throw new InvalidScoreException("Score must be between 0 and 100"); +throws Keyword throws is used in a method signature to indicate that the method may throw certain exceptions.❣️🌐 Used to declare exceptions Caller must handle them Mainly for checked exceptions Multiple exceptions can be declared Example: public void readData() throws IOException {} Key Takeaway Custom Exceptions give clarity and structure to business rules throw is used to trigger an exception throws is used to declare exceptions Together, they help build robust, readable, and professional Java applications.throw Keyword throw is used to manually throw an exception in the👉✨ Special thanks to our mentor Anand Kumar Buddarapu Sir for simplifying exception handling with real-world examples. Thanks to Saketh Kallepu Sir, Uppugundla Sairam Sir, and the entire Codegnan Team for their continuous motivation. #Java #ExceptionHandling #CustomExceptions #throwVsThrows #Codegnan #FullStackDevelopment #LearningJourney #OOPS #LogicBuilding #120DaysOfCodeChallenge

I learned Java basics. ↓ Wrote some API. ↓ Introduced a new dependency to a common package. ↓ The common package was being used in 80+ other packages. ↓ How hard can production be? ↓ Merged my CR on Friday night. ↓ Went to sleep. ↓ Woke up to 30 Slack messages. ↓ Build was failing in 80+ pipelines. ↓ Debugged the issue. ↓ Fixed the issue in some packages I had access to over the weekend. ↓ Wrote a detailed doc explaining the cause and the fix before the Slack avalanche. ↓ The issue got fixed in all the pipelines. ↓ Now, I try not to merge CRs on Fridays anymore (especially at night). Here’s the thing -  Every engineer starts with a naive first version. And every production failure teaches you something no tutorial ever could. You don’t grow by writing perfect code - you grow by breaking things, figuring out why they broke, and rebuilding them stronger. Crashes aren’t setbacks; they’re lessons. And the earlier they happen, the better. :)