<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mohamed El Laithy on Medium]]></title>
        <description><![CDATA[Stories by Mohamed El Laithy on Medium]]></description>
        <link>https://medium.com/@mohamed547754?source=rss-523534813c6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tstTuvfmtOyRB29NXaYPvg.jpeg</url>
            <title>Stories by Mohamed El Laithy on Medium</title>
            <link>https://medium.com/@mohamed547754?source=rss-523534813c6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:25:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mohamed547754/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Java 27: Every New Feature Explained (Complete Guide)]]></title>
            <link>https://medium.com/@mohamed547754/java-27-every-new-feature-explained-complete-guide-707cc60df651?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/707cc60df651</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 08:52:06 GMT</pubDate>
            <atom:updated>2026-09-17T09:57:25.894Z</atom:updated>
            <content:encoded><![CDATA[<h3>The full rundown of what shipped in September 2026, and whether any of it actually belongs in your stack</h3><p>Java 27 shipped in September 2026, and if you’ve searched “Java 27” hoping for a straight answer on what changed, this is that answer. Every JEP that landed, what it means in practice, and a straight recommendation on whether you should touch it.</p><p>Quick answer, if you’re in a hurry: Java 27 is a non-LTS release: fully production-ready, but public updates end when Java 28 ships, roughly six months out. It adds almost no new syntax. What it does is switch two years of JDK 25 experiments on by default: G1 becomes the only garbage collector, object headers shrink by up to a third, and TLS gets quantum-resistant key exchange with no fanfare. Three language and concurrency previews keep iterating (Structured Concurrency, Primitive Types in Patterns, Lazy Constants), plus the Vector API’s twelfth incubation round. None of it needs code changes to benefit from, and none of it is a reason to jump off a Java 25 LTS deployment.</p><p>If you want the deep version, keep reading.</p><h3>Is Java 27 an LTS release?</h3><p>No. Here’s where it sits on the release train:</p><p>Version Type Released Supported until Java 8 LTS Mar 2014 Dec 2030 (extended) Java 11 LTS Sep 2018 Sep 2026 (extended) Java 17 LTS Sep 2021 Sep 2029 (extended) Java 21 LTS Sep 2023 Sep 2031 (extended) Java 25 LTS Sep 2025 Sep 2033 (extended) Java 27 Non-LTS Sep 2026 ~6 months, until Java 28</p><p>Java ships a new feature release every six months, but only one release in four gets long-term support. Java 27 is the second feature release after Java 25 LTS. Non-LTS doesn’t mean lower quality: every feature release is production-ready and goes through the same testing. The difference is the support window. Public updates for 27 stop when Java 28 ships, so running it in production means committing to upgrade every six months. Teams with solid CI and test coverage do this routinely; teams that upgrade less often are better served by an LTS.</p><h3>What actually changed: JVM defaults</h3><p>This is the part most “Java 27 features” roundups skip past: they list the JEPs and stop. Here’s what each one actually does to a running application.</p><h3>G1 is now the only default garbage collector (JEP 523)</h3><p>Before 27, the JVM’s default GC depended on how much memory and how many CPUs it saw at startup. A single-CPU or sub-1,792MB machine, a common shape for a small container, would silently get Serial GC instead of G1. JEP 523 removes that branch entirely: G1 is the default everywhere regardless of container size.</p><p>If you were relying on Serial GC’s lower overhead for a small sidecar or batch job, that choice becomes explicit on 27. -XX:+UseSerialGC still works; it just stops being handed to you by default.</p><h3>Compact Object Headers are on by default (JEP 534)</h3><p>Every object on the Java heap carries a header, 96 bits (12 bytes) of mark word and class pointer, before your fields even start. JEP 534 shrinks that to 64 bits (8 bytes) and makes it the default. The JEP’s own early-adopter numbers report 10 to 20% less heap usage for typical small-object workloads.</p><p>The part most write-ups skip: HotSpot rounds every object’s total size up to a multiple of 8 bytes, so the actual savings depend on whether the smaller header pushes an object across a rounding boundary. We benchmarked this directly across five object shapes (0 to 4 int fields): results ranged from 0% to 50% smaller, not a flat percentage. If your app allocates a lot of small objects (caches, DTOs, graph structures), it&#39;s worth measuring on your own object shapes rather than trusting an average.</p><h3>JFR redacts secrets automatically (JEP 536)</h3><p>Java Flight Recorder now redacts values that look like passwords, tokens, or API keys, in environment variables and system properties, before they hit a recording file. One less way for a profiling session to leak a secret into a shared .jfr file.</p><h3>Security: quantum-resistant TLS</h3><h3>Post-Quantum Hybrid Key Exchange for TLS 1.3 (JEP 527)</h3><p>This is the headline security story in 27. TLS 1.3 connections now automatically negotiate a hybrid key exchange, classical ECDHE combined with the NIST-standardized ML-KEM algorithm, whenever both peers support it. No code changes, no new API to call.</p><p>The threat model is “harvest now, decrypt later.” An adversary doesn’t need a working quantum computer today to benefit from one later; they can record encrypted traffic now, store it, and decrypt it once the hardware catches up. For anything that needs to stay confidential for years, that’s worth planning around now.</p><p>Three new named groups ship: X25519MLKEM768, SecP256r1MLKEM768, and SecP384r1MLKEM1024, each pairing a classical curve with an ML-KEM variant. We tested this directly against a live server on JDK 25: requesting the hybrid group alone fails outright (JDK 25 doesn&#39;t implement it yet), while offering it alongside a classical fallback succeeds and negotiates down instead. That fallback behavior is what makes it safe to start requesting early.</p><h3>PEM Encodings, third preview (JEP 538)</h3><p>A standard API for reading and writing PEM-encoded keys and certificates, instead of every project hand-rolling its own Base64/DER parsing. Still a preview; needs --enable-preview.</p><h3>Language: pattern matching closes its last gap</h3><h3>Primitive Types in Patterns, fifth preview (JEP 532)</h3><p>Pattern matching has worked cleanly on objects since records and sealed types landed. Primitives were the exception until now. switch and instanceof can match directly against int, double, and boolean, guards included, no boxing required:</p><pre>int score = 82;<br>switch (score) {<br>  case int s when s &gt;= 90 -&gt; System.out.println(&quot;excellent&quot;);<br>  case int s when s &gt;= 75 -&gt; System.out.println(&quot;good&quot;);<br>  default                 -&gt; System.out.println(&quot;needs work&quot;);<br>}</pre><p>Five rounds of community feedback have already reshaped this once, so treat the exact syntax as close to final rather than guaranteed identical.</p><h3>Concurrency and core library: iteration, not invention</h3><p>Three previews already in flight get another round of refinement, based on real feedback:</p><p>Structured Concurrency, seventh preview (JEP 533), treats a group of related concurrent tasks as one unit: cancel together, fail together, no leaked threads. This round throws ExecutionException instead of a custom exception type, and onTimeout() is renamed to timeout().</p><p>Lazy Constants, third preview (JEP 531), is a holder for a value computed at most once, on first access. This round adds Set.ofLazy() to the family.</p><p>Vector API, twelfth incubator (JEP 537), is unchanged this cycle, still waiting on Project Valhalla’s value classes before it can graduate. We ran a real scalar-vs-vector benchmark on this exact incubator module: a dot-product kernel measured about 2x faster with 512-bit AVX-512 vectors, real numbers rather than a marketing claim, and the write-up covers exactly why it’s 2x and not 16x.</p><h3>Should you actually upgrade?</h3><p>Your situation Recommendation Production service on Java 21/25 LTS Stay, track 27’s features for your next LTS move Personal projects, early adopters Try 27 now, flip --enable-preview, and explore Security-critical / regulated systems Watch the post-quantum TLS story closely, plan your migration timeline Apps with many small objects, GC-sensitive Worth benchmarking, compact headers can be a real win</p><p>Nine JEPs, almost no new syntax finalized. For most production systems on an LTS release, none of this is urgent, but it’s worth knowing before your next upgrade cycle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CsujA00qhmlCREemcx4ZWw.png" /></figure><p><a href="https://gumroad.com/read/cf40e41c8b0f59f9b76da22c6a905b7a/2SO4LLe78u0omefIikgzhA==">Check out the key changes in Java 27 and what they mean for Java developers.</a></p><h3>Get the complete notes, free</h3><p>I put everything in this article, plus the full release timeline, a glossary, and a printable reference layout, into a free PDF: <a href="https://mellaithy.gumroad.com/l/hibernate-deep-dive">Java 27 Complete Notes</a>. It’s free to download, no catch.</p><p>If it saves you the time of reading nine JEPs yourself, a quick review on the page genuinely helps other people find it. I’d appreciate it.</p><p>I’m also building real, tested deep-dives on specific Java 27 features (actual benchmarked code, not just descriptions), starting with the Vector API and Compact Object Headers numbers above. Follow along at <a href="https://mellaithy.gumroad.com/">mellaithy.gumroad.com</a> if that’s useful to you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=707cc60df651" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 4-Second API: How a Hidden N+1 and a Blocking HTTP Call Took Down Our Order Service]]></title>
            <link>https://medium.com/@mohamed547754/the-4-second-api-how-a-hidden-n-1-and-a-blocking-http-call-took-down-our-order-service-d7069a9c0c84?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7069a9c0c84</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 06:52:10 GMT</pubDate>
            <atom:updated>2026-09-08T06:52:10.129Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WTynU5nJCvDCcxWR8olB-g.png" /></figure><h3>High latency with idle CPU is not a mystery — it’s a diagnosis. A P1 post-mortem on connection pool starvation in Spring Boot.</h3><p><em>API post-mortem on connection pool starvation in Spring Boot, and the three unglamorous fixes that brought p95 latency from 4.2s back to single digits.</em></p><h3>The alert nobody wants at peak hour</h3><p>Traffic was normal. Around 2,000 requests per minute. No deploy had gone out that day.</p><p>Then the dashboards lit up:</p><ul><li><strong>p95 latency: 180ms → 4,200ms</strong></li><li><strong>HikariCP saturation alerts firing continuously</strong> (pool size: 10)</li><li><strong>CPU under 40%</strong> across every pod</li><li><strong>~3% of responses returning orders with missing line items</strong></li><li>A mix of raw 500 stack traces and empty 200s going out to clients</li></ul><p>That third bullet is the one that told us what kind of problem we had.</p><p>If the CPU is idle while latency explodes, nobody is computing anything. Threads are sitting still, blocked on I/O, waiting for something that isn’t coming back fast enough.</p><p>So the question stopped being <em>“what’s slow”</em> and became <em>“what are we waiting on, and why are we holding a database connection while we wait.”</em></p><h3>Root cause: one endpoint, three anti-patterns</h3><p>Everything traced back to a single controller method. Here is what was actually running in production:</p><pre>@GetMapping(&quot;/orders/{userId}&quot;)<br>public List&lt;OrderDTO&gt; getOrdersByUser(@PathVariable Long userId) {<br>    List&lt;Order&gt; orders = orderRepository.findByUserId(userId);<br>    List&lt;OrderDTO&gt; result = new ArrayList&lt;&gt;();</pre><pre>    for (Order order : orders) {<br>        OrderDTO dto = new OrderDTO();<br>        dto.setId(order.getId());<br>        dto.setStatus(order.getStatus());</pre><pre>        // Triggers N+1: lazy loading inside the loop<br>        dto.setItems(order.getItems());</pre><pre>        // A synchronous 350ms HTTP call. Inside the same loop.<br>        dto.setPaymentStatus(paymentClient.getStatus(order.getId()));</pre><pre>        result.add(dto);<br>    }<br>    return result;<br>}</pre><p>It reads fine. That’s the problem with this class of bug: it passes code review, it passes tests against a seeded database with three orders, and it falls apart the moment a real customer with real history hits it.</p><h3>Issue 1: the N+1 query</h3><p>findByUserId fetches the orders. Then order.getItems() inside the loop lazily initializes the items collection, one order at a time. For N orders, Hibernate issues N+1 queries.</p><p>At low traffic this is invisible. At 2,000 req/min it multiplies your query volume by roughly the average number of orders per user.</p><h3>Issue 2: blocking I/O inside the loop</h3><p>This was the real killer. paymentClient.getStatus(...) is a synchronous REST call to an external Payment Service, averaging 350ms round trip.</p><p>With a typical 15 orders per user:</p><pre>15 × 350ms = 5,250ms</pre><p>Five seconds of network wait, in a loop, per request.</p><p>Now combine the two. That entire loop was running <strong>inside an open transaction</strong>, which means each request held a HikariCP connection for the full five seconds while doing nothing but waiting on a socket.</p><p>With a pool of 10, the arithmetic is brutal. Ten concurrent requests consume the entire pool. Every request after that queues on connection acquisition and eventually times out.</p><p>This is why the CPU stayed flat: the service was not overloaded, it was <strong>blocked</strong>.</p><p>Little’s Law makes it concrete:</p><pre>concurrency = arrival rate × latency</pre><p>When latency jumps from 180ms to 5s, in-flight requests grow by nearly 30×. No pool sized for the healthy case survives that.</p><h3>Issue 3: no transactional boundaries, no centralized error handling</h3><p>Because the lazy collections were sometimes touched outside an active transaction, some responses came back with uninitialized item lists. That’s the 3% of orders missing line items.</p><p>And with no @ControllerAdvice, each endpoint handled its own failures. Some leaked stack traces, some swallowed the exception and returned an empty 200. Clients had no consistent way to tell success from failure.</p><h3>The fix</h3><p>Three changes. None of them clever.</p><h3>1. Fetch the relation explicitly</h3><p>Replace the derived query with a JPQL query using LEFT JOIN FETCH, so orders and their items come back in one round trip.</p><pre>@Repository<br>public interface OrderRepository extends JpaRepository&lt;Order, Long&gt; {</pre><pre>    @Query(&quot;SELECT DISTINCT o FROM Order o LEFT JOIN FETCH o.items WHERE o.userId = :userId&quot;)<br>    List&lt;Order&gt; findByUserIdWithItems(@Param(&quot;userId&quot;) Long userId);<br>}</pre><p>An @EntityGraph works equally well here if you prefer to keep the query derived.</p><h3>2. Batch the external call, get it out of the loop</h3><p>The Payment Service already had the capability to accept multiple IDs. We just weren’t using it. One call replaces fifteen.</p><pre>@RestController<br>@RequestMapping(&quot;/orders&quot;)<br>public class OrderController {</pre><pre>    private final OrderRepository orderRepository;<br>    private final PaymentClient paymentClient;</pre><pre>    @GetMapping(&quot;/{userId}&quot;)<br>    @Transactional(readOnly = true)<br>    public List&lt;OrderDTO&gt; getOrdersByUser(@PathVariable Long userId) {<br>        List&lt;Order&gt; orders = orderRepository.findByUserIdWithItems(userId);<br>        if (orders.isEmpty()) return Collections.emptyList();</pre><pre>        List&lt;Long&gt; orderIds = orders.stream().map(Order::getId).toList();<br>        Map&lt;Long, String&gt; paymentStatuses = paymentClient.getStatusesInBatch(orderIds);</pre><pre>        return orders.stream().map(order -&gt; {<br>            OrderDTO dto = new OrderDTO();<br>            dto.setId(order.getId());<br>            dto.setStatus(order.getStatus());<br>            dto.setItems(order.getItems());<br>            dto.setPaymentStatus(paymentStatuses.getOrDefault(order.getId(), &quot;UNKNOWN&quot;));<br>            return dto;<br>        }).toList();<br>    }<br>}</pre><p>Two things worth calling out.</p><p>getOrDefault(..., &quot;UNKNOWN&quot;) means a partial failure in the payment lookup degrades one field instead of failing the whole response. And @Transactional(readOnly = true) gives us a defined boundary, so lazy access happens inside a live session rather than by luck.</p><p>If you can’t batch on the downstream side, the fallback is parallel calls on a bounded executor. The rule you cannot break is the one about holding a database connection while you wait on the network.</p><h3>3. Centralize exception handling</h3><pre>@RestControllerAdvice<br>public class GlobalExceptionHandler {</pre><pre>    @ExceptionHandler(Exception.class)<br>    public ResponseEntity&lt;Map&lt;String, String&gt;&gt; handleAllExceptions(Exception ex) {<br>        log.error(&quot;Unhandled exception&quot;, ex);<br>        return ResponseEntity<br>            .status(HttpStatus.INTERNAL_SERVER_ERROR)<br>            .body(Map.of(&quot;error&quot;, &quot;INTERNAL_SERVER_ERROR&quot;,<br>                         &quot;message&quot;, &quot;An unexpected error occurred.&quot;));<br>    }<br>}</pre><p>Log the full detail on our side, return a stable shape to the client. No more stack traces on the wire, no more silent empty 200s.</p><h3>Making it hold under burst: Redis</h3><p>The code fix solved the incident. It didn’t answer the next question, which was what happens when traffic goes past 2,000 req/min.</p><p>Order history is read-heavy and tolerant of being slightly stale, which makes it an easy caching target. We put @Cacheable on the read path with a 60-second TTL.</p><p>Sixty seconds was chosen deliberately. Long enough to absorb the repeated reads that dominate this endpoint, short enough that a status change surfaces well within what users notice.</p><h3>Results</h3><p>Metric Before After p95 latency 4,200ms &lt; 5ms on cache hit HikariCP pool usage Saturated at 100% Under 15% at peak DB query pressure Baseline Down ~85% Responses with missing items ~3% 0 Error responses Inconsistent 500s / empty 200s Consistent structured errors</p><h3>What I’d tell any Spring developer after this</h3><p><strong>Never put network or database I/O inside a loop.</strong> Batch it, or make it non-blocking. This one rule would have prevented the entire incident.</p><p><strong>A blocked thread holding a connection is worse than a slow one.</strong> Long I/O inside a transaction is how you exhaust a pool with modest traffic and idle CPUs. Do your external calls outside the transactional boundary.</p><p><strong>Fetch explicitly when you’re mapping to DTOs.</strong> JOIN FETCH or an entity graph. Never let lazy loading fire inside a mapping loop.</p><p><strong>Low CPU with high latency is a diagnosis, not a mystery.</strong> It means blocking I/O. Go look at your pools and thread dumps, not your algorithms.</p><p><strong>Centralize your error handling on day one.</strong> @ControllerAdvice costs ten minutes and saves you from leaking internals during the exact incident where you least want to be leaking internals.</p><p><strong>Test with realistic data volumes.</strong> Every one of these bugs is invisible with three seeded rows and obvious with fifteen.</p><p>Have you hit connection pool starvation or thread exhaustion in production? I’m curious which anti-pattern caused it, because in my experience it’s almost always this same shape wearing a different hat.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7069a9c0c84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[20 Agentic AI Terms Every Developer Should Actually Understand]]></title>
            <link>https://medium.com/@mohamed547754/20-agentic-ai-terms-every-developer-should-actually-understand-1cf562fa7ba0?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cf562fa7ba0</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Sun, 06 Sep 2026 06:28:51 GMT</pubDate>
            <atom:updated>2026-09-06T06:28:51.843Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JXVPJxgZODUOybZ60ZlK3Q.png" /></figure><p>If you’ve opened an “agent framework” repo in the last few months and felt like everyone in the README already knew something you didn’t — you’re not behind. The tooling didn’t get harder. The vocabulary just multiplied faster than anyone documented it.</p><p>Agent loop. Harness. MCP. A2A. Agentic RAG. Half of these sound like they were named in a meeting that ran too long. But once you’ve built even a small agent, they stop being buzzwords and start being the fastest way to describe what your code is actually doing.</p><p>So here are 20 of them — explained the way I’d explain them to a teammate sitting next to me, not the way a spec document would.</p><h3>The basics</h3><p><strong>1. AI Agent</strong> An AI agent is an LLM that’s allowed to take actions and decide what to do next, instead of replying once and stopping.</p><p><em>Example:</em> You ask “check why signups dropped yesterday.” A plain LLM guesses from what you typed. An agent queries your analytics DB, checks yesterday’s deploy log, and <em>then</em> answers — based on what it actually found.</p><p><strong>2. Agentic Workflow</strong> A workflow runs a fixed sequence of steps, even if an LLM handles one of them. An agent decides its own next step as it goes. This is the distinction that trips up the most people, so it’s worth sitting with: a workflow is a recipe, an agent is a cook deciding what the dish needs.</p><p><em>Example:</em> A workflow always runs summarize → categorize → assign, in that order, every time. An agent reads the ticket and decides for itself whether to categorize it, ask a clarifying question, or escalate first.</p><p><strong>3. Agent Loop</strong> The engine underneath every agent: <strong>Decide → Act → Observe → Decide</strong>, repeating until the goal is met or the agent gives up.</p><p><em>Example:</em> Decide: call checkInventory(). Act: makes the call. Observe: item is out of stock. Decide again: call notifySupplier() instead of confirming the order.</p><p><strong>4. Tool Calling</strong> An LLM can’t touch your database or APIs directly. Tool calling lets it <em>request</em> an action — your application executes it.</p><p><em>Example:</em> User asks “show me yesterday’s failed payments.” The agent requests getFailedPayments(), your app runs it and returns rows, and the agent explains the result. Rule of thumb: the model proposes, the application disposes.</p><p><strong>5. Agent Harness</strong> The LLM is just the brain. The harness is everything around it that makes an agent actually work — it manages tools, state, context, permissions, execution, and error handling.</p><p><em>Example:</em> The model wants to call an API and the call times out. The harness catches the failure, decides whether to retry, and feeds the result back — the model never sees a raw exception.</p><h3>Making agents actually work</h3><p><strong>6. Context Engineering</strong> Deciding <em>what</em> the model sees at each step — not writing one perfect prompt, but managing its window as a task unfolds over many steps.</p><p><em>Example:</em> Old steps get summarized, only relevant doc chunks get pulled in, and anything irrelevant gets dropped, so the model isn’t drowning in its own history by step 30.</p><p><strong>7. Memory</strong> How an agent keeps information beyond a single response — short-term within one conversation, or long-term across many.</p><p><em>Example:</em> Short-term: it remembers, within one chat, that you already tried restarting the app. Long-term: weeks later, it recalls that you always ask questions in Portuguese.</p><p><strong>8. MCP</strong> A standardized way for an AI application to plug into external tools and data, instead of hand-writing a custom integration for every single one. Conceptually: <strong>Agent ↔ MCP ↔ Tools / Data</strong>.</p><p><em>Example:</em> Instead of coding a Postgres client and a Jira client separately, your agent talks to both through MCP servers, the same way each time.</p><p><strong>9. Planning</strong> The agent breaking a goal into a sequence of steps before, or while, it acts.</p><p><em>Example:</em> Told to “ship this hotfix,” the agent plans: run tests → build → deploy to staging → notify the team. It doesn’t jump straight to deploying.</p><p><strong>10. Reasoning</strong> The model working through <em>why</em> before it acts — weighing options instead of grabbing the first plausible one.</p><p><em>Example:</em> Three near-identical tools exist: refundPayment(), voidPayment(), reversePayment(). Reasoning is the step where the agent works out which one actually fits this case, before calling any of them.</p><h3>When one agent isn’t enough</h3><p><strong>11. Multi-Agent Systems</strong> Instead of one agent trying to do everything, you split the work across several specialized agents — each narrower, and better at its one job.</p><p><em>Example:</em> A coder agent writes the diff, a reviewer agent checks it, a test agent runs the suite and reports back.</p><p><strong>12. Orchestration</strong> The layer deciding which agent runs when, in what order, and what data passes between them. The orchestrator itself doesn’t solve the task — it routes it.</p><p><em>Example:</em> An orchestrator classifies an incoming ticket, then routes billing questions to the billing agent and bugs to the technical agent.</p><p><strong>13. Handoff</strong> One agent explicitly passing control — and context — to another agent mid-task, so the user never has to repeat themselves.</p><p><em>Example:</em> A triage agent decides “this is a refund case” and hands off to a refund-specialist agent, passing the full conversation thread along with it.</p><p><strong>14. A2A</strong> Agent2Agent — a protocol for agents to talk directly to <em>other</em> agents, even ones built by a different team or vendor. Don’t confuse it with MCP: <strong>MCP is Agent ↔ Tools. A2A is Agent ↔ Agent.</strong></p><p><em>Example:</em> Your logistics agent needs shipment status from a partner company’s agent. A2A gives both sides a common way to ask and answer, without a custom integration.</p><h3>Keeping agents honest</h3><p><strong>15. Guardrails</strong> Rules and constraints that limit what an agent is allowed to do — enforced automatically, no human required.</p><p><em>Example:</em> The agent proposes DROP TABLE users;. A guardrail only allows SELECT statements. Blocked, every time, before execution.</p><p><strong>16. Human-in-the-Loop (HITL)</strong> A human has to review or approve an action before it actually happens. This is not the same thing as a guardrail: guardrails are automated rules, HITL is a person in the decision.</p><p><em>Example:</em> The agent drafts a $2,000 refund. Nothing moves until a support lead clicks approve.</p><p><strong>17. Evals</strong> Evaluating an agent isn’t only “was the final answer right?” You’re also checking tool selection, execution steps, task completion, and reliability across repeated runs.</p><p><em>Example:</em> An eval suite checks not just whether the final message was correct, but whether the agent called getOrderStatus() before issueRefund() — and does it consistently across 50 runs.</p><h3>Advanced patterns (and one red flag)</h3><p><strong>18. Computer Use</strong> When an agent operates a UI directly — clicking, typing, reading screenshots — instead of calling an API. Useful for the systems that never got one.</p><p><em>Example:</em> There’s no API for that 15-year-old internal admin panel, so the agent takes a screenshot, finds the right button, and clicks it like a person would.</p><p><strong>19. Agentic RAG</strong> Traditional RAG retrieves once and generates. Agentic RAG treats retrieval itself as something worth deciding about — turning one shot into a loop: decide what to retrieve → retrieve → evaluate → retrieve again if needed → generate.</p><p><em>Example:</em> The agent searches your docs, notices the results don’t actually answer the question, rewrites the query, searches again, and only then generates an answer.</p><p><strong>20. Agent Washing</strong> Slapping the “AI agent” label on something that’s really just a single prompt to an LLM — no loop, no tools, no autonomy.</p><p><em>Example:</em> A product calls its single-turn chatbot, built on one fixed prompt with zero tool access, an “autonomous AI agent.” Nothing is actually being decided. It’s a well-dressed prompt template.</p><p>You won’t remember all 20 of these today. But the first time you sit down to actually build an agent, you’ll bump into most of them within the first hour — and it’s a lot easier to bump into a term you’ve already seen once.</p><p>If you want more of this — practical Java, Spring Boot, backend engineering, and AI content without the fluff — I write about it regularly. Follow along, or check my notes and templates at <strong>mellaithy.gumroad.com</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cf562fa7ba0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You Don’t Need Python to Build AI Features — You Need Spring AI]]></title>
            <link>https://medium.com/@mohamed547754/you-dont-need-python-to-build-ai-features-you-need-spring-ai-5ff2daab59e8?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ff2daab59e8</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Thu, 03 Sep 2026 09:02:43 GMT</pubDate>
            <atom:updated>2026-09-03T09:02:43.204Z</atom:updated>
            <content:encoded><![CDATA[<p>100 Spring Boot project ideas, mapped to the actual stack for each one</p><h3>You Don’t Need Python to Build AI Features — You Need Spring AI</h3><p>There’s a quiet assumption a lot of Java developers carry around: if you want to add AI to your product, you need to reach for Python. Spin up a FastAPI service, wire it up to your Java backend over HTTP, and now you’re maintaining two stacks instead of one.</p><p>That assumption is wrong, and it’s costing people time.</p><p><strong>Spring AI</strong> gives you everything you need — ChatClient, VectorStore, function calling, structured output — inside the same Spring Boot application you already know how to build, test, and deploy. No second language, no second deployment pipeline, no second set of conventions to learn.</p><p>To prove the point, I put together <strong>100 project ideas</strong> you can build entirely with Spring Boot and Spring AI. Not a list of vague titles like “build a chatbot” — each one comes with the real stack behind it.</p><p>Here’s a sample of five, so you can see the level of detail:</p><ul><li><strong>Support Bot with RAG</strong> — Spring AI + pgvector + QuestionAnswerAdvisor</li><li><strong>Meeting Notes Summarizer</strong> — BeanOutputConverter mapped straight to ActionItem records</li><li><strong>Natural Language to SQL</strong> — JDBC DatabaseMetaData used for schema context</li><li><strong>Repo-Aware Coding Agent</strong> — Tree-sitter + VectorStore + function calling</li><li><strong>Voice Support Agent</strong> — WebSocket audio + RAG + function calling</li></ul><h3>Three levels, so there’s an entry point wherever you are</h3><p>I split the 100 ideas into three tiers:</p><p><strong>1–40 · Beginner</strong> — getting comfortable with Spring Boot + Spring AI: your first ChatClient calls, prompt templates, simple conversational endpoints.</p><p><strong>41–80 · Intermediate</strong> — RAG and integrations: vector stores, document ingestion pipelines, structured output, calling external services from inside a model’s response.</p><p><strong>81–100 · Advanced</strong> — agents and orchestration: multi-step reasoning, tool-calling agents, and systems that coordinate multiple models or services together.</p><h3>Why I’m building these one at a time, in public</h3><p>Rather than dump 100 titles and walk away, I’m building these projects myself, one by one — real code, real architecture decisions, and the parts that break along the way (something always does). Each finished project becomes its own write-up: what I built, why I made the choices I made, and the code itself.</p><p><strong>Want the full list of all 100 projects, with the stack for each one, as a PDF?</strong> <a href="https://gumroad.com/d/cb594272e6b0be09ff172a0d1f250751">Download it here</a> — save it for later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/664/1*ppomeUhZTimb4pPWVrsIhg.png" /></figure><p>If you want each one the day it’s finished, I publish the full series on my Substack — <a href="https://claude.ai/cowork/cse_01U3bB2ymQ75atLUfFvp72jq#">subscribe here</a> to follow along.</p><p>I also run a small, focused community for Java developers building with Spring Boot and Spring AI — a place to talk through ideas and share what you’re working on: <a href="https://www.linkedin.com/groups/42445007/">Global Java Developers Community</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eSg9nCm2dUKQS1u5wkXGYw.png" /></figure><p><em>Which project should I build first? Leave the number — or your own idea — in the comments. I’m picking the next build from what people suggest.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ff2daab59e8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker for Java Developers: What You Actually Need to Know for Interviews]]></title>
            <link>https://medium.com/@mohamed547754/docker-for-java-developers-what-you-actually-need-to-know-for-interviews-ea8e0553fe2e?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea8e0553fe2e</guid>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 10:44:10 GMT</pubDate>
            <atom:updated>2026-08-29T10:44:10.874Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2MJ35DQtbjkpbSMAdwjGcg.png" /></figure><p>One thing I’ve noticed while preparing for Java interviews:</p><p>You can be comfortable with Java and Spring Boot and still get stuck when the interviewer starts asking about Docker.</p><p>Not because Docker is extremely difficult.</p><p>But because there are many concepts that developers learn separately:</p><p><strong>Images. Containers. Dockerfiles. Volumes. Networks. Compose. Ports.</strong></p><p>The real challenge is connecting them together and understanding how they apply to a Java application.</p><p>So I created a short <strong>Docker for Java Developers — Interview Guide</strong> focused specifically on interview preparation.</p><p>The goal isn’t to give you another huge Docker textbook.</p><p>It’s to give you a practical reference you can review before an interview and use to refresh the concepts that matter.</p><p>If you’re a:</p><ul><li>Java Developer</li><li>Spring Boot Developer</li><li>Backend Engineer</li><li>Software Engineer</li><li>Developer preparing for technical interviews</li></ul><p>this guide is for you.</p><p>📘 <strong>Get the guide here:</strong> <a href="https://gumroad.com/d/31c412338a37d631f6c7348807cdfd12?utm_source=chatgpt.com">Docker for Java Developers — Interview Guide</a></p><p>Study it. Save it. Come back to it before your next interview.</p><p>And if you’re currently preparing for Java interviews, don’t focus only on Java syntax.</p><p>Understand the tools around the application too.</p><p>Follow for more content:</p><p>Instagram: <a href="https://www.instagram.com/mellaithy.tech/">https://www.instagram.com/mellaithy.tech/</a></p><p>Substack: <a href="https://substack.com/@mellaithy">https://substack.com/@mellaithy</a></p><p>LinkedIn: <a href="https://www.linkedin.com/in/mohamed-el-laithy-0155b2173/">https://www.linkedin.com/in/mohamed-el-laithy-0155b2173/</a></p><p>#Java #Docker #SpringBoot #BackendDevelopment #SoftwareEngineering #TechInterviews #DevOps</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea8e0553fe2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Understanding Java Threading with Two Powerful Cheat Sheets to Remember All Java Thread Topics]]></title>
            <link>https://medium.com/@mohamed547754/understanding-java-threading-with-two-powerful-cheat-sheets-to-remember-all-java-thread-topics-83ca8e87bff4?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/83ca8e87bff4</guid>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 18:44:00 GMT</pubDate>
            <atom:updated>2026-01-05T18:44:37.218Z</atom:updated>
            <content:encoded><![CDATA[<p>🧠 Keep forgetting Java thread concepts?<br>These cheat sheets help lock them into your memory.</p><p>💼 Download the complete Java Cheat Sheets Pack 👇<br>🔗 <a href="https://mohamedmind11.gumroad.com/l/dev-cheatsheets">https://mohamedmind11.gumroad.com/l/dev-cheatsheets</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*3KyJqKHidIcr1UOny3g9vQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*1fCo_sNdQZPIXXMiD_SMOw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83ca8e87bff4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[For Anyone Curious About How Companies Deploy Enterprise Projects]]></title>
            <link>https://medium.com/@mohamed547754/for-anyone-curious-about-how-companies-deploy-enterprise-projects-a5d3afe8c10e?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5d3afe8c10e</guid>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Mon, 07 Jul 2025 07:59:49 GMT</pubDate>
            <atom:updated>2025-07-07T07:59:49.727Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi everyone!</p><p>I wanted to share a <strong>visual guide</strong> that shows the <em>end-to-end flow</em> of how companies typically deliver code to production.</p><p>This is especially useful if you’re wondering <strong>how companies deploy large-scale or enterprise projects</strong>, regardless of tech stack.</p><p>From <strong>planning</strong> and <strong>development</strong> to <strong>testing</strong>, <strong>deployment</strong>, and <strong>monitoring</strong>, this diagram highlights typical stages and common tools used in real-world pipelines.</p><h3>Overview</h3><p>Here’s a high-level process many companies follow:</p><p><strong>1. Planning &amp; Story Creation</strong></p><ul><li>Using tools like Jira to create and pick stories.</li><li>Product Owners define requirements.</li></ul><p><strong>2. Development &amp; Code Commit</strong></p><ul><li>Developers pick stories and commit code.</li><li>Code review and feedback cycles.</li></ul><p><strong>3. Build &amp; Store Artifacts</strong></p><ul><li>Tools like SonarQube, JUnit, Jacoco for static analysis and testing.</li><li>Builds stored in repositories like JFrog Artifactory.</li></ul><p><strong>4. Deploy to Environments</strong></p><ul><li>Dev Environment (Docker, Cloud).</li><li>QA Environment.</li><li>UAT Environment.</li></ul><p><strong>5. Production Deployment</strong></p><ul><li>Supports advanced strategies like Feature Toggles, Canary Deployments, A/B Testing.</li></ul><p><strong>6. Monitoring &amp; Alerting</strong></p><ul><li>Using tools like Prometheus, SkyWalking.</li><li>SRE teams ensure reliability.</li></ul><h3>Example Tools &amp; Technologies</h3><ul><li><strong>Planning</strong>: Jira</li><li><strong>Code Quality</strong>: SonarQube, JUnit, Jacoco</li><li><strong>Build/Artifact Storage</strong>: JFrog Artifactory</li><li><strong>Containers</strong>: Docker</li><li><strong>Cloud Platforms</strong>: AWS, GCP, Azure</li><li><strong>Monitoring</strong>: Prometheus, SkyWalking</li></ul><h3>Who Is This For?</h3><p>This kind of process is essential for:</p><p>✔️ New developers learning CI/CD and release workflows<br> ✔️ Teams improving their delivery pipelines<br> ✔️ SREs &amp; DevOps refining deployment strategies<br> ✔️ AI/ML teams productionizing models</p><h3>💬 Discussion</h3><p>What does your delivery pipeline look like?<br> Which tools do <em>you</em> use at each stage?<br> How does your team manage releases to production?</p><p>👇 Share your thoughts in the comments. Let’s learn from each other!</p><h3>📸 Image</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/1*3Bd-63N7hcAYHliXX1ZJfQ.gif" /></figure><h3>Tags</h3><p>#devops #softwareengineering #cicd #java #python #ai #cloud #deployment #sre</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5d3afe8c10e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How SOLID Principles Saved My Project: A Developer’s Story]]></title>
            <link>https://medium.com/@mohamed547754/how-solid-principles-saved-my-project-a-developers-story-d20c8aa0c80b?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/d20c8aa0c80b</guid>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Mon, 09 Jun 2025 09:29:36 GMT</pubDate>
            <atom:updated>2025-06-09T09:41:25.317Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>A real-world story on how understanding SOLID turned chaos into clarity.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hlI9w_SoujqtzQrb9UdsUA.png" /></figure><h3>It All Started With One Class…</h3><p>I still remember the moment. I was working on a payment feature for an e-commerce system. At first, everything lived inside one gigantic class: user validation, discount logic, payment processing — you name it. As deadlines loomed and requirements shifted, every code change felt like pulling a loose thread in a sweater. Nothing made sense anymore.</p><p>I needed help. Fast.</p><h3>The Wake-Up Call</h3><p>One late night, I found myself in yet another endless debugging session. That’s when a senior engineer looked at my screen and calmly said:</p><blockquote><em>“You’re breaking almost every SOLID principle here.”</em></blockquote><p>I’d heard of SOLID before, but never truly applied it.</p><h3>Applying SOLID (And Saving My Sanity)</h3><p><strong>S — Single Responsibility:</strong><br> I split the class into smaller ones: UserService, DiscountService, PaymentProcessor. Suddenly, each file had <em>just one job</em>.</p><p><strong>O — Open/Closed:</strong><br> Adding support for new payment methods no longer meant rewriting the core logic — just extending interfaces.</p><p><strong>L — Liskov Substitution:</strong><br> We introduced a base NotificationService, and easily swapped in email, SMS, or push notifications without changing existing code.</p><p><strong>I — Interface Segregation:</strong><br> No more bloated interfaces! We created focused interfaces so classes only had to implement the methods they truly needed.</p><p><strong>D — Dependency Inversion:</strong><br> We stopped directly instantiating classes. Instead, we injected dependencies. Testing became painless.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*ZOJcF6iB7CER_A7i_LUslA.gif" /></figure><h3>The Impact</h3><p>SOLID wasn’t just a fancy acronym — it reshaped how we designed software. The project became more maintainable, the team was less stressed, and our bugs dropped dramatically.</p><p>Now, every time I review a design or mentor a teammate, I start with this question:</p><blockquote><em>“Are we respecting SOLID principles?”</em></blockquote><h3>Final Thought</h3><p>You don’t have to learn everything at once. Start by applying <strong>one principle at a time</strong>. Your future self will thank you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d20c8aa0c80b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[All Spring Frameworks with Features]]></title>
            <link>https://medium.com/@mohamed547754/all-spring-frameworks-with-features-20be0a131ca2?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/20be0a131ca2</guid>
            <category><![CDATA[spring-framework]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Mon, 26 May 2025 05:59:49 GMT</pubDate>
            <atom:updated>2025-05-27T11:40:01.572Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Upo8f5To1rX84r4RcYl4AA.png" /></figure><p>If you’re working with Java, you’ve definitely come across <strong>Spring</strong> — the most powerful and widely-used framework in the Java ecosystem. But Spring isn’t just one thing. It’s an entire <strong>ecosystem of frameworks</strong> designed to make development faster, safer, and more scalable.</p><p>In this article, I’ll walk you through <strong>all the major Spring frameworks</strong>, what they’re used for, and their key features — all in a beginner-friendly way.</p><h3>1. Spring Framework (Core)</h3><p>This is the <strong>foundation</strong> of everything in the Spring world. It introduced the concepts of <strong>Dependency Injection (DI)</strong> and <strong>Aspect-Oriented Programming (AOP)</strong>, which help you write cleaner, more modular code.</p><p><strong>Key Features:</strong></p><ul><li>Dependency Injection (Inversion of Control)</li><li>AOP for cross-cutting concerns (like logging or transactions)</li><li>Integration with JDBC, JMS, JPA, etc.</li><li>Event-driven programming support</li></ul><h3>2. Spring Boot</h3><p>Spring Boot is a <strong>game-changer</strong>. It makes it incredibly easy to start a new Spring application with minimal configuration. You can literally spin up a web app in minutes.</p><p><strong>Key Features:</strong></p><ul><li>Auto-configuration</li><li>Embedded servers (Tomcat, Jetty, etc.)</li><li>Minimal boilerplate</li><li>Production-ready metrics with Spring Boot Actuator</li></ul><h3>3. Spring MVC</h3><p>Spring MVC is the traditional web framework for building both <strong>REST APIs</strong> and <strong>HTML-based web apps</strong>. It follows the classic Model-View-Controller pattern.</p><p><strong>Key Features:</strong></p><ul><li>REST controller support</li><li>Flexible request mapping</li><li>View resolution (JSP, Thymeleaf, etc.)</li><li>Built-in form validation</li></ul><h3>4. Spring Security</h3><p>Security is critical for any application. Spring Security provides a <strong>comprehensive security solution</strong> for Java applications.</p><p><strong>Key Features:</strong></p><ul><li>Authentication and Authorization</li><li>Supports OAuth2, JWT, and LDAP</li><li>Password encoding</li><li>CSRF, CORS protection</li></ul><h3>5. Spring Data</h3><p>Working with databases? Spring Data helps you deal with data access layers by <strong>abstracting most of the boilerplate code</strong>.</p><p><strong>Popular Modules:</strong></p><ul><li>Spring Data JPA (for relational DBs)</li><li>Spring Data MongoDB, Redis (NoSQL)</li><li>Spring Data R2DBC (reactive SQL)</li></ul><p><strong>Key Features:</strong></p><ul><li>Repository pattern with auto-implemented methods</li><li>Paging and sorting</li><li>Query derivation from method names</li></ul><h3>6. Spring Cloud</h3><p>Spring Cloud is designed for <strong>microservices and cloud-native development</strong>. It simplifies building distributed systems that need things like configuration management and service discovery.</p><p><strong>Key Features:</strong></p><ul><li>Config Server (centralized configuration)</li><li>Eureka (Service Discovery)</li><li>Spring Cloud Gateway (API Gateway)</li><li>Circuit Breakers (Resilience with Resilience4j/Hystrix)</li><li>Distributed tracing (Spring Cloud Sleuth)</li></ul><h3>7. Spring WebFlux</h3><p>WebFlux is Spring’s <strong>reactive web framework</strong> built on Project Reactor. It’s designed for building <strong>non-blocking, asynchronous applications</strong>.</p><p><strong>Key Features:</strong></p><ul><li>Reactive Streams support</li><li>Mono and Flux APIs</li><li>Works with Netty, Undertow, etc.</li><li>Ideal for real-time apps (chat, streaming)</li></ul><h3>8. Spring Batch</h3><p>Need to process millions of records in chunks? Spring Batch is your go-to framework for <strong>batch processing</strong>.</p><p><strong>Key Features:</strong></p><ul><li>Step-by-step job configuration</li><li>Chunk-based processing</li><li>Retry and skip logic</li><li>Job restart support</li></ul><h3>9. Spring Integration</h3><p>This framework is based on <strong>Enterprise Integration Patterns (EIP)</strong> and helps connect different systems using <strong>message-driven architecture</strong>.</p><p><strong>Key Features:</strong></p><ul><li>Message channels and gateways</li><li>Filters, routers, transformers</li><li>Adapters for file, JMS, email, etc.</li></ul><h3>10. Spring AMQP</h3><p>Built for messaging with <strong>RabbitMQ</strong>, Spring AMQP simplifies handling <strong>asynchronous communication</strong> in microservices.</p><p><strong>Key Features:</strong></p><ul><li>RabbitTemplate for sending messages</li><li>Message converters</li><li>Declarative listener containers</li></ul><h3>11. Spring Authorization Server</h3><p>This is a relatively new project that provides a <strong>fully-featured OAuth2 and OpenID Connect Authorization Server</strong>.</p><p><strong>Key Features:</strong></p><ul><li>Token issuance (Access, Refresh, ID tokens)</li><li>PKCE, scopes, and claims</li><li>Integration with Spring Security</li></ul><h3>12. Spring REST Docs</h3><p>Spring REST Docs lets you <strong>generate beautiful API documentation directly from your integration tests</strong>.</p><p><strong>Key Features:</strong></p><ul><li>Works with MockMvc or WebTestClient</li><li>AsciiDoc and HTML output</li><li>Accurate and up-to-date documentation</li></ul><h3>13. Spring Test</h3><p>Spring provides extensive support for <strong>testing your application</strong> using unit, integration, and web layer tests.</p><p><strong>Key Features:</strong></p><ul><li>@SpringBootTest, @DataJpaTest, @WebMvcTest</li><li>Embedded databases (like H2)</li><li>MockMvc for REST APIs</li><li>Test slicing</li></ul><h3>14. Spring Modulith</h3><p>Helps structure modular monolith applications with clear boundaries and internal architecture.</p><p><strong>Key Features:</strong></p><ul><li>Support for modular development in a monolith</li><li>Enforces architectural boundaries</li><li>Domain events between modules</li><li>Built-in observability and documentation</li><li>Integrates seamlessly with Spring Boot</li></ul><h3>15. Spring for Apache Pulsar</h3><p>Provides first-class integration with Apache Pulsar for event streaming and messaging.</p><p><strong>Key Features:</strong></p><ul><li>PulsarTemplate for sending messages</li><li>Declarative listener support</li><li>Schema and topic configuration</li><li>Simplified producer/consumer management</li></ul><h3>16. Spring GraphQL</h3><p>A framework for building GraphQL APIs with Spring Boot.</p><p><strong>Key Features:</strong></p><ul><li>Integration with GraphQL Java</li><li>Annotations and controllers similar to Spring MVC</li><li>Subscription (WebSocket) support</li><li>Data fetchers and resolvers</li><li>Error handling and exception mapping</li></ul><h3>17. Spring Authorization Server</h3><p>While this was experimental in early versions, it’s now the official Spring OAuth2 Authorization Server.</p><p><strong>Key Features:</strong></p><ul><li>OAuth2 and OpenID Connect 1.0 support</li><li>Token management and customization</li><li>Client registration and consent flows</li><li>Fully customizable and extensible</li><li>Integration with Spring Security</li></ul><h3>18. Spring AI</h3><p>Provides abstractions to integrate AI and LLM (Large Language Model) features into Spring apps.</p><p><strong>Key Features:</strong></p><ul><li>Support for OpenAI, Hugging Face, Cohere, etc.</li><li>Chat-based and embedding models</li><li>Vector Store integration (Redis, Milvus, etc.)</li><li>Prompt templating</li></ul><h3>19. Spring CLI v3</h3><p>The new Spring CLI includes modern commands for initializing, running, and managing projects — and integrates with the new Spring Initializr and Spring AI.</p><p><strong>Key Features:</strong></p><ul><li>spring boot new for creating projects</li><li>spring boot run with live reload</li><li>Plugin system</li><li>Works well with Spring Boot 3+ and modularity tools</li></ul><h3>20. Spring AOP</h3><p>Spring AOP is not a standalone framework — it’s a core module within the main Spring Framework. It provides Aspect-Oriented Programming capabilities, which are used to separate cross-cutting concerns from business logic.</p><p>To modularize concerns like logging, security, transactions, and monitoring without cluttering core business logic.</p><p><strong>Key Features:</strong></p><ul><li>Aspect: A module that encapsulates a cross-cutting concern.</li><li>Join Point: A point in the application (e.g., method call) where an aspect can be applied.</li><li>Advice: Code to be executed at a join point (e.g., <a href="http://twitter.com/Before">@Before</a>, <a href="http://twitter.com/After">@After</a>, <a href="http://twitter.com/Around">@Around</a>).</li><li>Pointcut: Expression to match join points (e.g., methods with specific annotations or names).</li><li>Weaving: Process of applying aspects to the target object.</li><li>Proxy-based AOP: Uses JDK dynamic proxies or CGLIB at runtime.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*-JjcglE7sCss3raDGIKx3Q.gif" /></figure><h3>Final Thoughts</h3><p>The <strong>Spring ecosystem is huge</strong>, but each project is designed with a clear purpose to solve real-world problems in software development. Whether you’re building a simple web app or a complex microservice architecture, there’s a Spring project for it.</p><p>💬 <em>Which Spring framework do you use the most? Drop a comment below!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20be0a131ca2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 Effective Methods to Enhance API Performance]]></title>
            <link>https://medium.com/@mohamed547754/5-effective-methods-to-enhance-api-performance-1dc92d9c253e?source=rss-523534813c6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1dc92d9c253e</guid>
            <dc:creator><![CDATA[Mohamed El Laithy]]></dc:creator>
            <pubDate>Fri, 23 May 2025 13:18:38 GMT</pubDate>
            <atom:updated>2025-05-23T13:19:12.757Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*-rrN8r_0aPb0XIlnWw_dvg.gif" /><figcaption>Animated Diagram</figcaption></figure><ol><li>Pagination<br>Implementing pagination helps manage large datasets efficiently by returning results in smaller chunks. This reduces response size, accelerates data retrieval, and improves the overall user experience.</li></ol><p>2. Asynchronous Logging<br>Instead of writing logs to disk on every request, logs are temporarily stored in a buffer and written periodically. This minimizes I/O bottlenecks and enhances API responsiveness by reducing processing delays.</p><p>3. Connection Pooling<br>Maintaining a pool of reusable connections reduces the overhead of establishing new database connections repeatedly. This improves efficiency, decreases latency, and allows the system to handle a higher number of concurrent users.</p><p>4. Load Balancer<br>A load balancer efficiently distributes incoming requests among multiple servers, preventing any single server from being overwhelmed. This ensures better resource utilization, higher fault tolerance, and increased system availability.</p><p>5. Caching<br>Storing frequently requested data in a cache reduces the need for repeated database queries. Solutions like Redis improve response times by keeping frequently accessed data in memory, enhancing overall API speed.</p><p>Over to you: What other ways do you use to improve API performance?<br>#systemdesign<br>#coding<br>#ApiPerformance</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1dc92d9c253e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>