<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" media="screen" href="/~files/feed-premium.xsl"?>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
<rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:feedpress="https://feed.press/xmlns" xmlns:podcast="https://podcastindex.org/namespace/1.0" version="2.0">
  <channel>
    <feedpress:locale>en</feedpress:locale>
    <atom:link rel="self" href="https://feeds.dzone.com/frameworks"/>
    <atom:link rel="hub" href="https://feedpress.superfeedr.com/"/>
    <title>DZone Frameworks Zone</title>
    <link>https://dzone.com/frameworks</link>
    <description>Recent posts in Frameworks on DZone.com</description>
    <item>
      <title>9 Practical Ways to Fix Laravel Performance Issues in Production</title>
      <link>https://feeds.dzone.com/link/23563/17498348/laravel-performance-production</link>
      <description><![CDATA[<p data-pm-slice="1 1 []">A Laravel application can feel instant on a developer laptop and painfully slow after a few months in production. The framework is rarely the real problem. More often, the database has grown, a relationship is being loaded inside a loop, a report pulls far more rows than anyone expected, or a third-party API has quietly become part of the request's critical path.</p>
<p>If you are trying to learn how to fix <a href="https://dzone.com/articles/laravel-for-beginners-an-overview-of-the-php-frame">Laravel</a> performance issues in production, resist the urge to begin with Redis, Octane, or a larger server. First, find the work the request shouldn't be doing. Removing wasted work usually produces a bigger, safer improvement than adding infrastructure around it.</p><img src="https://feeds.dzone.com/link/23563/17498348.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 15 Oct 2026 17:00:04 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3681463</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19234952&amp;w=600"/>
      <dc:creator>Ankit Khoiwal</dc:creator>
    </item>
    <item>
      <title>Going All In On the JVM 25 Virtual Threads</title>
      <link>https://feeds.dzone.com/link/23563/17497693/jvm-25-virtual-threads</link>
      <description><![CDATA[<p><span style="margin: 0px; padding: 0px;">The project <a href="https://github.com/Angular2Guy/AngularAndSpring" target="_blank">AngularAndSpring</a> has been refactored from Spring Reactor to Spring blocking APIs using JDK 25 and virtual threads.</span></p>
<h2>The Old Architecture</h2>
<p>The reason <a href="https://github.com/Angular2Guy/AngularAndSpring" rel="noopener noreferrer" target="_blank">AngularAndSpring</a> was built using Spring Reactor was primarily the efficient use of operating system threads and memory under high load. Spring Reactor had a limited thread pool (usually the number of available CPU cores) and used OS threads only when the CPU had work to do. It did not let the operating system threads sleep. This used CPU resources much better and required far fewer OS threads, each of which needs around a megabyte of memory.</p><img src="https://feeds.dzone.com/link/23563/17497693.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 14 Oct 2026 18:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3686105</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19213124&amp;w=600"/>
      <dc:creator>Sven Loesekann</dc:creator>
    </item>
    <item>
      <title>Kafka With Spring Boot: Introduction</title>
      <link>https://feeds.dzone.com/link/23563/17494736/kafka-with-spring-boot</link>
      <description><![CDATA[<p>Kafka is a distributed event streaming platform that enables real-time data ingestion, storage, and processing of continuous event streams. To do that, Kafka has a complex internal structure. In this part, I will try to cover an overview of the full internal structure.</p>
<h2><strong>Overview</strong></h2>
<p><a href="https://dzone.com/articles/kafka-powerhouse-messaging">Kafka</a> uses a publish-subscribe model where producers produce events and consumers consume messages. Kafka producers publish events to the broker, and consumers consume the events from the broker. In the meantime, the broker has a different layer of architecture that allows Kafka to be an event streaming platform. The producer, broker, and consumer-related metadata are managed by the Kafka controller, which is elected by ZooKeeper or KRaft.&nbsp;</p><img src="https://feeds.dzone.com/link/23563/17494736.gif" height="1" width="1"/>]]></description>
      <pubDate>Mon, 12 Oct 2026 16:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3664523</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19225193&amp;w=600"/>
      <dc:creator>Sanjoy Kumer Deb</dc:creator>
    </item>
    <item>
      <title>AWS 7R Migration Strategies: A Decision Framework for Engineering Teams</title>
      <link>https://feeds.dzone.com/link/23563/17482175/aws-7r-migration-strategies</link>
      <description><![CDATA[<p data-line="16" dir="auto">Most AWS migration projects don't fail because of technical complexity. They fail because teams treat migration as a single activity rather than a set of distinct strategies applied to different workloads.</p>
<p data-line="18" dir="auto"><a href="https://dzone.com/articles/aws-resources-to-help-you-get-started-in-the-cloud">AWS</a> defines seven migration strategies — the 7Rs — that determine how each application moves to the cloud. The decision of which strategy applies to which workload has more impact on project cost, timeline, and outcome than any architectural choice you'll make after. Yet in practice, most teams default to "lift-and-shift everything" without evaluating whether that's appropriate.</p><img src="https://feeds.dzone.com/link/23563/17482175.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 30 Sep 2026 16:00:06 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3666942</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19117167&amp;w=600"/>
      <dc:creator>Jerzy Kopaczewski</dc:creator>
    </item>
    <item>
      <title>Integrating LLMs into iOS Applications With Swift Using ONNX Runtime</title>
      <link>https://feeds.dzone.com/link/23563/17472436/integrating-llms-with-swift</link>
      <description><![CDATA[<p>Artificial Intelligence has become one of the most influential technologies in modern software development. From chatbots and recommendation systems to sentiment analysis and intelligent search, machine learning models are now expected features in many mobile applications.</p>
<p>For several years, integrating AI into iOS applications almost always meant sending user data to cloud services. <a href="https://dzone.com/articles/apis-in-motion-keep-your-apis-up-to-date">APIs</a> such as OpenAI, Anthropic Claude, and Google Gemini allowed developers to leverage state-of-the-art language models without worrying about infrastructure or hardware limitations. While this approach is simple, it also introduces several challenges, including network latency, API costs, internet dependency, and privacy concerns.</p><img src="https://feeds.dzone.com/link/23563/17472436.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 24 Sep 2026 15:00:03 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3664554</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19200455&amp;w=600"/>
      <dc:creator>Kagan Girgin</dc:creator>
    </item>
    <item>
      <title>SpaceXAI Launches Grok 4.7: Low Prices, Heavy Token Use</title>
      <link>https://feeds.dzone.com/link/23563/17472109/news-spacexai-grok-4-7</link>
      <description><![CDATA[<p dir="ltr">Grok 4.7 promises stronger AI coding performance without a higher base price, but heavy token consumption could reduce those savings.</p>
<p dir="ltr">SpaceXAI released Grok 4.7 on Sept. 21 as its latest model for coding and professional knowledge work. According to the company, it uses a larger base model than Grok 4.6 and underwent a longer reinforcement-learning run focused on difficult tasks that can take hours to complete.</p><img src="https://feeds.dzone.com/link/23563/17472109.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 24 Sep 2026 09:14:30 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3688438</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19219243&amp;w=600"/>
      <dc:creator>Aminu Abdullahi</dc:creator>
    </item>
    <item>
      <title>Stop Blaming Executor Memory: The Real Reasons Your Spark Jobs Are Slow</title>
      <link>https://feeds.dzone.com/link/23563/17466071/spark-jobs-slow-performance</link>
      <description><![CDATA[<p>After a decade of building and debugging large-scale data pipelines across financial services, payments processing, and analytics platforms, I can tell you that almost every slow Spark job I've investigated had the same root cause — and it wasn't the one the team thought it was.&nbsp;</p>
<p><span>The default response when a&nbsp;</span><a href="https://dzone.com/articles/apache-spark-all-you-need-to-know"><span>Spark</span></a><span>&nbsp;job is slow is to add more executor memory, increase the number of executors, or bump spark.sql.shuffle.partitions. Sometimes that helps. Usually it doesn't. What I've found, consistently, is that the real problems are structural — a join strategy mismatch that silently multiplies your intermediate dataset by ten times, a single slow task on a degraded node that holds an entire stage hostage, or a decrypt chain that re-reads source data six times when it only needed to read it once.</span></p><img src="https://feeds.dzone.com/link/23563/17466071.gif" height="1" width="1"/>]]></description>
      <pubDate>Fri, 18 Sep 2026 13:00:03 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3664522</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19193601&amp;w=600"/>
      <dc:creator>Swaminathan Sethuraman</dc:creator>
    </item>
    <item>
      <title>A Practical Framework for Scoping an AI Proof of Concept</title>
      <link>https://feeds.dzone.com/link/23563/17461622/ai-poc-practical-framework</link>
      <description><![CDATA[<p dir="ltr">Most AI proof-of-concept projects don't break down while they're building. They fall down on scoping, weeks before coding is even written. If the objective is unclear, data is unavailable, or a success is not defined, a two-week experiment becomes a two-month drift, showing no return to a stakeholder.</p>
<p dir="ltr">I've seen this on my own projects and on teams that I have worked on. The solution is simple, and it does: formulate the POC as a question with a number behind it, and then determine how to find out the answer.</p><img src="https://feeds.dzone.com/link/23563/17461622.gif" height="1" width="1"/>]]></description>
      <pubDate>Mon, 14 Sep 2026 14:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3664107</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19182507&amp;w=600"/>
      <dc:creator>Paul Schloss</dc:creator>
    </item>
    <item>
      <title>Angular Apps Don’t Need Another Chatbot: Building Agentic UI Workflows With TypeScript</title>
      <link>https://feeds.dzone.com/link/23563/17444691/angular-agentic-ui</link>
      <description><![CDATA[<p>A chatbot can explain data, summarize a screen, or answer questions, yet the application still behaves largely as before: business state lives elsewhere, actions remain disconnected from model output, and the interface is reduced to a transcript. Agentic UI takes a different approach. The model becomes a planner over explicit application capabilities, while Angular remains responsible for state, rendering, validation, authorization boundaries, and interaction. Angular’s current AI guidance already distinguishes basic chat experiences from agentic workflows and dynamic server-driven interfaces, while protocols such as AG-UI formalize streaming state and tool events between agent backends and frontends.&nbsp;</p>
<h2>Chat Is an Output Channel, Not the Application Model</h2>
<p>The key design shift is to model an agent run as a workflow rather than a sequence of messages. A purchasing screen, for example, can expose inventory lookup, draft modification, approval, and submission as capabilities. Natural language may start the flow, but the resulting interface should remain a normal application UI: editable fields, status indicators, review cards, validation messages, and explicit confirmation controls. <a href="https://dzone.com/articles/mcp-vs-a2a-vs-agui">AG-UI</a> follows this direction by defining lifecycle, text, tool-call, and state events instead of treating every interaction as plain assistant text. Tool calls are represented through structured events, allowing a frontend to represent work in progress without attempting to parse model prose into application behavior.&nbsp;</p><img src="https://feeds.dzone.com/link/23563/17444691.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 10 Sep 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3681449</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19185133&amp;w=600"/>
      <dc:creator>Bhanu Sekhar Guttikonda</dc:creator>
    </item>
    <item>
      <title>A Field Guide to AI Agent Frameworks</title>
      <link>https://feeds.dzone.com/link/23563/17444407/ai-agent-frameworks</link>
      <description><![CDATA[<p dir="ltr">I have spent most of 2026 writing about agent frameworks on DZone. In <a href="https://dzone.com/articles/mcp-vs-skills-vs-agents">MCP vs Skills vs Agents With Scripts</a>, I made the case that these are not competing choices; they are layers you stack. In <a href="https://dzone.com/articles/loop-engineering-llms">Loop Engineering</a> and the follow-up on <a href="https://dzone.com/articles/understanding-graph-engineering">Graph Engineering</a>, I went a level deeper into how the loop itself gets structured once you decide to build something. This month the question changed shape on me again. It stopped being "how do I build an agent" and became "which of the fifteen tools with agent in the pitch do I actually install?"</p>
<p dir="ltr">So I widened the comparison. This piece covers the managed AI teammate apps (Grok Bot, Claude Cowork, CellCog), the open-source runtimes you host yourself (OpenWork, OpenClaw), and the developer frameworks you write code against when a packaged app will not cut it (LangGraph, CrewAI, AutoGen, Microsoft Agent Framework, Google ADK, the Claude Agent SDK, Pydantic AI), plus where no-code tools like n8n still fit. Same rule as always: I am not picking a winner. I am telling you which one matches the job in front of you.</p><img src="https://feeds.dzone.com/link/23563/17444407.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 10 Sep 2026 14:00:05 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3681282</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19185113&amp;w=600"/>
      <dc:creator>Vidyasagar (Sarath Chandra) Machupalli FBCS</dc:creator>
    </item>
    <item>
      <title>The Startup Time Trick Hiding Inside Your Docker Build</title>
      <link>https://feeds.dzone.com/link/23563/17439260/docker-build-startup-time</link>
      <description><![CDATA[<p data-sourcepos="3:1-3:427;58-484" dir="ltr">Every Java developer who runs services on Kubernetes has watched this scene play out. Traffic spikes, the autoscaler adds a pod, and then everyone waits. The container is running in two seconds. The application is not ready for another twelve seconds. During those ten seconds, your existing pods absorb the extra load, latency climbs, and if things are bad enough, the autoscaler panics and adds even more pods that are also not ready.</p>
<p data-sourcepos="5:1-5:370;486-855" dir="ltr">I spent years treating Spring Boot startup time as a fact of life, the way you treat weather. Then I found out the JVM has had a fix for a big chunk of it since Java 12; it works beautifully inside Docker, and almost nobody bakes it into their images. It is called Class Data Sharing, CDS for short, and this article shows you how to make your Docker build do the work</p><img src="https://feeds.dzone.com/link/23563/17439260.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 03 Sep 2026 18:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3669942</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19166206&amp;w=600"/>
      <dc:creator>Garima Agarwal</dc:creator>
    </item>
    <item>
      <title>Stop Hardcoding Database Checks: Building a Metadata-Driven Data Quality Framework</title>
      <link>https://feeds.dzone.com/link/23563/17436500/building-metadata-driven-quality-framework</link>
      <description><![CDATA[<p>In high-volume data platforms, hardcoding validation logic into individual processing pipelines creates significant operational drag. As an enterprise data asset footprint grows, maintaining manual checks for hundreds of tables inevitably leads to mounting technical debt, silent schema drift, and a fragmented audit trail.</p>
<p>To achieve data governance at scale, data architects must decouple validation rules from the execution engine. By utilizing a centralized metadata repository to dynamically generate validation suites, organizations can transform data quality from a reactive, script-based bottleneck into a configuration-driven infrastructure asset.</p><img src="https://feeds.dzone.com/link/23563/17436500.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 01 Sep 2026 15:00:05 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3663212</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19160959&amp;w=600"/>
      <dc:creator>Kshitish Nath</dc:creator>
    </item>
    <item>
      <title>Pure Headless vs Hybrid Headless CMS: A Practical Decision Framework</title>
      <link>https://feeds.dzone.com/link/23563/17432375/pure-vs-hybrid-headless-cms</link>
      <description><![CDATA[<p><span>Headless&nbsp;</span><span>CMS architecture</span><span>&nbsp;solved a real development problem. It separated content from presentation, gave frontend teams control over frameworks and deployment, and made structured content available to websites, apps, and other channels through APIs.</span></p>
<p><span>The friction often appears later, when content operations become more complex. Routine publishing changes can still depend on engineering, especially when editors need more control over layout, preview, or page composition.</span></p><img src="https://feeds.dzone.com/link/23563/17432375.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 26 Aug 2026 16:00:11 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3673251</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19149225&amp;w=600"/>
      <dc:creator>Alex Vakulov</dc:creator>
    </item>
    <item>
      <title>Understanding RabbitMQ Exchange Types in Spring Boot</title>
      <link>https://feeds.dzone.com/link/23563/17432246/rabbitmq-exchange-types-spring-boot</link>
      <description><![CDATA[<div>
 <p>In this blog, you will take a closer look at the different exchange types that can be used in RabbitMQ. All are demonstrated by means of examples in a Spring Boot application. Enjoy!</p>
 <h2>Introduction</h2>
 <p>In the <a href="https://dzone.com/articles/rabbitmq-spring-boot" rel="noopener noreferrer" target="_blank">previous blog,</a> you learned the basic concepts of RabbitMQ and how to use it in a Spring Boot application. However, you only scratched the surface of it, so now it is time to dig a bit deeper into the different exchange types.</p><img src="https://feeds.dzone.com/link/23563/17432246.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 26 Aug 2026 13:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3673218</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19151339&amp;w=600"/>
      <dc:creator>Gunter Rotsaert</dc:creator>
    </item>
    <item>
      <title>Containerizing Spark and Lakehouse Development with Docker</title>
      <link>https://feeds.dzone.com/link/23563/17428447/containerize-development-with-docker</link>
      <description><![CDATA[<p>Most Docker content targets web developers shipping stateless services. However, data engineers, who represent a huge and growing population of Dockers users, are mostly left to figure things out alone, and it shows. The get pipelines that pass locally, but explode on clusters. They pit notebook-only development against expensive cloud workspaces, and more. This article applies six years of production data platform experience in financial services and healthcare to a question nobody answers well: How to you make a laptop behave like a lakehouse?&nbsp;</p>
<h2>A Familiar Routine</h2>
<p>If you build data pipelines for a living, you've lived this story. Your PySpark job runs perfectly in a cloud notebook. You productionize it, push it through CI, deploy it to the cluster, and it fails. A dependency mismatch. A different Spark minor version. A Delta Lake protocol feature your local wheel doesn't know about. A timezone default nobody set.</p><img src="https://feeds.dzone.com/link/23563/17428447.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 25 Aug 2026 19:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3659665</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19124070&amp;w=600"/>
      <dc:creator>Aniket Abhishek Soni</dc:creator>
    </item>
    <item>
      <title>Demystifying Thread Hopping With Swift 6.2</title>
      <link>https://feeds.dzone.com/link/23563/17428213/swift-demystifies-tread-hopping</link>
      <description><![CDATA[<p>Ever since <a href="https://dzone.com/articles/swift-actors-executors-reentrancy" rel="noopener noreferrer" target="_blank">Swift Concurrency</a> was introduced, its main mission has been clear: keep memory safe without making us write callback hell. But if we’re being honest, context switching-specifically thread hopping-has always been a bit of a head-scratcher.</p>
<p>How many times have you marked an async function as <code>nonisolated</code> on a <code>@MainActor</code> class, only to watch it instantly jump off to the cooperative global pool for no obvious reason?</p><img src="https://feeds.dzone.com/link/23563/17428213.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 25 Aug 2026 14:00:14 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3666637</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19111640&amp;w=600"/>
      <dc:creator>Nikita Vasilev</dc:creator>
    </item>
    <item>
      <title>Cutting AI Token Costs With MgntUtils Stack Trace Filtering</title>
      <link>https://feeds.dzone.com/link/23563/17427538/ai-token-costs-stack-traces</link>
      <description><![CDATA[<p><em>A live production integration case study.</em></p>
<h2><a name="introduction-and-purpose-of-this-article" href="https://dev.to/mgantman/cutting-ai-token-costs-with-mgntutils-stacktrace-filtering-52hc#introduction-and-purpose-of-this-article"></a>Introduction and Purpose of This Article</h2>
<p>This article is written for mid- and high-level managerial and technical decision-makers. I am the author of the open-source Java library <a href="https://dzone.com/articles/filter-java-stacktrace-mgntutils">MgntUtils</a>. The article presents an analysis of a <strong>real integration</strong> of the stack trace-filtering feature from that library into a live commercial production environment.</p><img src="https://feeds.dzone.com/link/23563/17427538.gif" height="1" width="1"/>]]></description>
      <pubDate>Mon, 24 Aug 2026 14:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3670070</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19148135&amp;w=600"/>
      <dc:creator>Michael Gantman</dc:creator>
    </item>
    <item>
      <title>Stop Hand-Rolling Chat UIs: Streaming LLM Tokens Into React Native Without the Jank</title>
      <link>https://feeds.dzone.com/link/23563/17424654/streaming-llm-tokens-into-react-native</link>
      <description><![CDATA[<p>A chat screen looks like a weekend project: a list of bubbles and a text input pinned to the bottom. In React Native, it is one of the hardest things to ship well, because it sits on top of the two most hostile surfaces in mobile development: the software keyboard and a scrolling list that changes size while you're looking at it.</p>
<p>We're putting LLMs into everything now, and there is still no good drop-in chat view for React Native. You glue together an aging library with strong opinions, or you hand-roll it. I hand-rolled it. Then I made the LLM stream its replies token by token, and the whole thing fell apart in a way that took a week to understand.</p><img src="https://feeds.dzone.com/link/23563/17424654.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 20 Aug 2026 18:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3660826</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19146110&amp;w=600"/>
      <dc:creator>Tammo Ronke</dc:creator>
    </item>
    <item>
      <title>Benchmark LangGraph, Strands, OpenAI Agents, and Google ADK on the Same Agent Graph</title>
      <link>https://feeds.dzone.com/link/23563/17417415/agent-framework-benchmark</link>
      <description><![CDATA[<p>Agent framework debates are mostly vibes. One engineer swears LangGraph is faster, another prefers the OpenAI Agents SDK, someone wants Google ADK because it feels future-proof. The team picks one, wires the workflow into its SDK, and the choice is welded in. Changing frameworks later means tearing out the wiring for one SDK and rebuilding the workflow on another, an expensive rewrite few teams take on.</p>
<p>This tutorial makes that decision reversible and then settles it with data. You put the <a href="https://launchdarkly.com/docs/home/agentcontrol/agent-graphs" rel="noopener noreferrer" target="_blank">agent graph</a> in LaunchDarkly and run four frameworks (<a href="https://langchain-ai.github.io/langgraph/" rel="noopener noreferrer" target="_blank">LangGraph</a>, <a href="https://strandsagents.com/" rel="noopener noreferrer" target="_blank">Strands</a>, <a href="https://openai.github.io/openai-agents-python/" rel="noopener noreferrer" target="_blank">OpenAI Agents SDK</a>, and <a href="https://google.github.io/adk-docs/" rel="noopener noreferrer" target="_blank">Google ADK</a>) over the same topology, with the model pinned so the framework is the only variable. A LaunchDarkly <a href="https://launchdarkly.com/docs/home/agentcontrol/experimentation" rel="noopener noreferrer" target="_blank">experiment</a> ranks them on graph latency and token use, with an LLM judge guarding quality. The results table tells you which framework runs your graph fastest without degrading it.</p><img src="https://feeds.dzone.com/link/23563/17417415.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 13 Aug 2026 16:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3661989</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19134892&amp;w=600"/>
      <dc:creator>Scarlett Attensil</dc:creator>
    </item>
    <item>
      <title>A Framework-Agnostic Approach to SSR for Microfrontends</title>
      <link>https://feeds.dzone.com/link/23563/17414852/ssr-for-microfrontends</link>
      <description><![CDATA[<p data-pm-slice="1 1 []">On one of our projects, we were building microfrontends, and at some point we wanted to add SSR. The reasons were the usual ones: better first paint, fewer layout shifts, real content for crawlers, less JS to load before something appears on screen.</p>
<p>Setting it up turned out to be harder than I expected. There was no obvious out-of-box path that fit our setup, and most of the approaches I found either assumed a shared build or asked us to add new infrastructure on top of what we already had.</p><img src="https://feeds.dzone.com/link/23563/17414852.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 11 Aug 2026 13:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3665466</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19127538&amp;w=600"/>
      <dc:creator>Vitaly Zheltko</dc:creator>
    </item>
  </channel>
</rss>
