<?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 Santanu Dey on Medium]]></title>
        <description><![CDATA[Stories by Santanu Dey on Medium]]></description>
        <link>https://medium.com/@mlbits?source=rss-4c51234fe872------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*8dCbseX_1KUCujImemt48A.jpeg</url>
            <title>Stories by Santanu Dey on Medium</title>
            <link>https://medium.com/@mlbits?source=rss-4c51234fe872------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 14:57:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mlbits/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[Agent Identity — Evolving Capabilities]]></title>
            <link>https://mlbits.medium.com/agent-identity-evolving-capabilities-de5f4a3c8268?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/de5f4a3c8268</guid>
            <category><![CDATA[identity]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Thu, 01 Oct 2026 07:41:40 GMT</pubDate>
            <atom:updated>2026-10-01T07:41:40.119Z</atom:updated>
            <content:encoded><![CDATA[<p>AI assistants initially were used for providing advice; today’s agents can make decisions, call tools, delegate tasks and execute transactions. Potentially a single interaction or a task can cross multiple trust boundaries. Hence organizations must ensure every action has a known actor, accountability trace, i.e., a lineage trace linking it to a human owner, regardless of the context in which it is operating.</p><p>The scenario somewhat like below, where agents working in context of an user request or an application delegating some task.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FRusw0qbPwv3PUwQbksrSg.png" /></figure><p>Looking at the typical scenario above helps us identify broad capabilities needed for agent identity, at a high-level:</p><ol><li><strong>Workload identity management: </strong>Assign verifiable identities to transient workloads at agentic scale.</li><li><strong>Authentication: </strong>Authenticate agents across trust boundaries without sharing credentials, while distinguishing individual agents, users and sessions.</li><li><strong>Authorization:</strong> Avoid user impersonation by granting agents delegated privileges constrained by scope, time and permitted use.</li><li><strong>Enforcement:</strong> Enforce access controls and context-aware policies at runtime, invoking human approval for high-risk actions.</li><li><strong>Governance:</strong> Maintain agent and MCP registries that support discovery, monitoring and end-to-end observability.</li></ol><blockquote><em>It is unusally hard to enable these capabilities at agentic scale</em></blockquote><p>Traditional identity systems were designed for people, applications and relatively stable workloads. AI agents break these assumptions. They can be created on demand, change tasks, call tools, cross organizational boundaries and delegate work to other agents — often within a single request. As a result, identity and access controls must operate dynamically and at machine-speed.</p><p>The challenge begins with <strong>workload identity management</strong>. Every transient agent instance needs a unique, verifiable identity tied to a known owner and purpose. At agentic scale, potentially thousands of short-lived workloads must be identified without creating an unmanageable registry.</p><p><strong>Authentication</strong> is equally complex. Agents must prove who they are across APIs, MCP servers and other trust boundaries without sharing or embedding credentials. Systems must also distinguish the agent by the user, session and workload it is associated with.</p><p>Next comes <strong>authorization</strong>. Agents should not simply impersonate users and inherit all their privileges. They need explicitly delegated authority constrained by scope, duration, purpose and permitted use — even when tasks are delegated again. The whole lineage of delegation must be preserved. Also at agentic scale, thousands of user consents leading to human fatigue is a real usability issue. And as agent behavior and context may change, access decisions cannot rely solely on permissions granted at the beginning of a session. Every meaningful action may require a fresh, context-aware policy check, and if needed override the authorization to invoke human approval, especially when the risk is high.</p><p>Finally, organizations need <strong>governance</strong> at scale. Agent and MCP registries must support discovery, ownership tracking and lifecycle management, while monitoring and observability provide evidence of what happened, under whose authority and why. Below is a more granular view of these requirements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MV23E2SlRldTKo67jxZKXA.png" /></figure><p>The central difficulty is not enabling any one these capabilities. It is making identity, authentication, authorization, enforcement and governance work together in a coherent manner — across these sprawling landscape of autonomous, often short-lived and interconnected agents.</p><p>Meeting these requirements means extending enterprise IAM with a coordinated set of technology capabilities rather than relying on a single product.</p><ul><li>SPIFFE based identity solution can establish workload identity and attestation, while enterprise identity providers support identity linkage and cross-domain authentication.</li><li>OAuth 2.1 with PKCE and RFC 8693 token exchange enable scoped delegation and short-lived credential brokering without exposing persistent secrets to agents.</li><li>Identity gateways and context-aware policy engines then enforce access decisions, shield downstream tokens, apply revocation and pause high-risk actions for human approval.</li><li>Finally, observability, audit, and agent and MCP registries connect identities, grants, decisions, approvals and outcomes to accountable owners.</li></ul><p>These components map across the five pillars defined earlier — identity, authentication, authorization, enforcement and governance — and represent integrated responsibilities, not a prescribed execution sequence or a set of standalone products.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bVtvcnJdfGeZ9Kt9ddJ4eg.png" /></figure><p>Finally I will strongly recommend to look at these body of evolving standards, relevant for Agent Identity Implementations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YUchh3aGC3qZIjCm0yKHpg.png" /></figure><p>And finally, Agent identity should be implemented as a phased journey, as the tech landscape itself is evolving. Start by making every agent traceable: establish workload identities, bind them to runtime instances, register accountable owners and capture observable activity.</p><p>The goal is steady progression from traceable agents, to bounded authority, to adaptive oversight. This phased approach allows enterprises to expand and adapt to emerging solutions as the industry progresses.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de5f4a3c8268" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Thoughts on Agentic Identity]]></title>
            <link>https://mlbits.medium.com/design-thoughts-on-agentic-identity-6f0fa710975f?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f0fa710975f</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-agent-identities]]></category>
            <category><![CDATA[identity-management]]></category>
            <category><![CDATA[agent-identity]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 07:31:29 GMT</pubDate>
            <atom:updated>2026-08-26T07:31:29.941Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Challenges of Agent Identity &amp; Access Management</strong></h3><p>Agentic systems are capable of executing multi-step and autonomous workflows, access data, external tools, with minimal human interventions. Traditional IAM systems with long-lived identities can not address this use case because agentic workflows are not pre-determined, and agents are ephemeral. With autonomy of agents, IAM policies need to evaluate their privileges based on the intent. Moreover, the speed with which new agents can be launched dynamically can be too much for traditional IAM systems. Finally, when users are carrying out agentic workflows the agents are actually having delegated authority, they should not be designed to impersonate of the user. All these challenges complicate Agentic Identity solution.</p><p>The proposed architecture solves the credential exposure problem by introducing a highly isolated, zero-trust credential shielding pattern. It leverages several critical industry specifications (OAuth 2.1, PKCE, RFC 8693 Token Exchange, SPIFFE/SPIRE, OPA, and MCP) to ensure the agent can execute tasks without ever possessing bearer tokens.</p><h3>Solution Design</h3><p>This is the core of the solution in a brief sequence diagram — omitting many details such as negative flows and variations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PPq2ohlX1ZnOPwSyLqwCrA.png" /></figure><ul><li><strong>Steps 1–2:</strong> The SPIRE Node Agent get attested by the SPIRE server.</li><li><strong>Steps 3–4:</strong> The user interacts with a GUI-based AI app, prompting the App Orchestrator to create the AI Agent and trigger a workflow. The whole interaction is tied to a specific Session ID.</li><li><strong>Steps 5–6:</strong> The AI Agent requests identification from the local SPIRE Node Agent (Already attested in step 1–2), which then issues a SVID to the agent. SVID is a <a href="https://spiffe.io/docs/latest/spiffe-about/overview/">SPIFFE</a> concept.</li><li><strong>Steps 7–8:</strong> The Agent determines it needs to act on behalf of the user to access an MCP (Model Context Protocol) server. It returns execution to the Orchestrator, passing its agent SVID and the target MCP in order to seek users consent.</li><li><strong>Steps 9–16 (3-Legged OAuth 2.1 with PKCE):</strong> The Orchestrator redirects the user to the Authorization Server. The authorization request includes a code_challenge for PKCE. Following user consent and a redirect, the Orchestrator requests a token using the authorization code and code_verifier, successfully acquiring the user Access Token.</li><li><strong>Steps 17–18 (RFC 8693 Token Exchange):</strong> The Orchestrator submits a token exchange request to the Authorization Server, specifying the audience (aud: MCP), the actor (act: SVID), the requested scope, and the user&#39;s Access Token. The Authorization Server mints and returns the composite OBO-token.</li><li><strong>Steps 19–20:</strong> The Orchestrator securely saves the OBO token in the Credential Broker, keyed against the Agent SVID and Session ID.</li><li><strong>Steps 21–22:</strong> The Orchestrator triggers the MCP call flow, prompting the Agent to send the request to the AI Identity Gateway with its agent SVID and Session ID.</li><li><strong>Steps 23–24:</strong> The Gateway retrieves the corresponding OBO token from the Credential Broker using the SVID and Session ID.</li><li><strong>Step 25:</strong> The Gateway validates the token and its claims. To support this, the gateway periodically retrieves the JWKS from the Authorization Server.</li><li><strong>Steps 26–27:</strong> The Gateway queries the Open Policy Agent (OPA) to validate if the token claims can be allowed against the organizations access policies, receiving a context-aware policy response.</li><li><strong>Steps 28–30:</strong> The Gateway forwards the MCP call to the MCP Server, injecting the OBO token into the Authorization Header. The MCP server (which trusts the Authorization Server) processes the request and returns the response to the Gateway, which passes it back to the Agent.</li></ul><h3>Key Benefits</h3><p>Key benefits of this approach include:</p><ul><li><strong>Workload Identity Tied to the Infrastructure:</strong> By utilizing SPIRE node and workload attestation, the system ensures that only cryptographically verified Agent instances, running on attested compute nodes, can request or utilize delegated credentials.</li><li><strong>Small Blast Radius for Tokens:</strong> The AI Agent never directly handles the raw user Access Token or the downstream OBO (On-Behalf-Of) token; it only holds its own SPIFFE SVID. The AI Identity Gateway and Credential Broker act as an outbound proxy, effectively neutralizing prompt injection attacks aimed at exfiltrating bearer credentials.</li><li><strong>Delegation over Impersonation:</strong> Implementing RFC 8693 Token Exchange allows the agent’s identity to be explicitly recorded as the actor. This preserves non-repudiation, ensuring the downstream Resource Server knows both the user who granted consent and the specific agent workload executing the action.</li><li><strong>Context-Aware Policy Enforcement:</strong> Before any tool is executed, an Open Policy Agent (OPA) evaluates the claims, providing dynamic, context-aware policy enforcement at the gateway level.</li></ul><p>I intend to publish additional notes on this topic in subsequent write-ups.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f0fa710975f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Create coding agents for automated conversion of Spring-boot application to Quarkus]]></title>
            <link>https://mlbits.medium.com/creating-a-coding-agent-for-automated-conversion-of-spring-boot-application-to-quarkus-e250b6312052?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/e250b6312052</guid>
            <category><![CDATA[quarkus]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Sat, 25 Apr 2026 03:52:10 GMT</pubDate>
            <atom:updated>2026-04-25T05:24:32.512Z</atom:updated>
            <content:encoded><![CDATA[<h3>Quarkus and support for Ahead-of-time Compilation</h3><p>Native compilation of Java application can speed-up application start-up times significantly, which is an important and sought after property for cloud-native containerized applications. To that end, a framework like Quarkus has gained a lot of traction. Notably it supports AOT (ahead-of-time) compilation using GraalVM. And hence it starts-up significantly better than JIT (default Just-in-time) compilation. You can refer to the link below for a good explanation of how this works:</p><p><a href="https://www.infoq.com/articles/native-java-quarkus/">Kubernetes Native Java with Quarkus — InfoQ</a></p><p>One of the obvious target for this shift is the Spring-boot microservices. While Spring is an excellent framework for developer productivity, separation of concerns and decoupling your classes by allowing dependency injection in the runtime, it cannot compete with Quarkus on start-up times or memory footprints.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qvfnIvwA7ez-EtMGZqBvQg.png" /></figure><p>Source: <a href="https://tech-stack.com/blog/using-graalvm-in-a-real-world-scenario-techstacks-experience/">https://tech-stack.com/blog/using-graalvm-in-a-real-world-scenario-techstacks-experience/</a></p><h3>Why Refactoring is challenging</h3><p>Dependency Injection (DI) is a fundamental concept of Spring.</p><p><strong>Which constructs in Spring uses DI?</strong></p><p>Spring-specific annotations ( @Autowired, @Component, @Service, @Repository, stereotype meta-annotations) plus configuration classes and @Bean methods.</p><p><strong>CDI (Context and Dependency Injection) in Quarkus</strong></p><p>In Spring, many things like object creation and dependency injection happen at runtime via reflection. In Quarkus, the “Spring translation” happens when you compile the app. This is why Quarkus is so much faster, but it also means you can’t do certain dynamic runtime tricks that Spring allows.</p><p>Quarkus has a concept called: CDI (Context and Dependency Injection). CDI does bean discovery, wiring, and validation at <strong>build time</strong>. Generates bytecode to avoid reflection and runtime classpath scanning. Fast startup, low memory, great for native images. Bean scanning and much of the wiring happen at runtime (with some Ahead-of-Time options available in newer Spring Native/Spring Boot 3 + GraalVM, but the traditional model is binding at runtime).</p><p>In Quarkus the clean target is CDI with @Inject, @ApplicationScoped, @Singleton, and producer methods. Quarkus also documents that @ComponentScan is unnecessary.</p><p>Hence, it is clear that refactoring the DI elements manually can be a lot of work — almost like a whole rewrite.</p><h3>Using AI instructions to Refactor from Spring to Quarkus</h3><p>Think about the main prompt as a workflow and the supporting artifacts as rules to execute those steps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*4ddecqqt7Z07PukZka10wg.png" /></figure><p>Think about the pain prompt as a workflow, and the supporting artifacts as the rules to execute the workflow steps.</p><ul><li><strong>Rules </strong>— saved rules provide very detailed instructions for guidelines for analysing, structure for mapping code/packages, standards for coding, testing, reviewing etc.</li><li><strong>Workflows </strong>— Workflows provides a single command way of running a series of complex tasks. Workflow steps can refer to rules. Very precise context can be supplied to a workflow step using files, folders in the IDE workspace.</li></ul><p>Next, here are the examples of the agent prompts and rules-</p><p><strong>Note </strong>that this agentic instructions are heavily copied from this example by Robin Foe here <a href="https://github.com/robinfoe/learn-ai">https://github.com/robinfoe/learn-ai</a></p><p><strong>migrate-to-quarkus.md</strong></p><pre># Migrate to Quarkus<br><br>Follow the instructions here to migrate the Spring Boot application @source-spring-app-folder to a new Quarkus based application. <br><br>## 1. Analyze the source application using rules/analyze.md and remember the output for the next steps. Also save the output in the /output folder.<br><br>## 2. Create a migration plan using rules/migration-rules.md and remember this plan for the next steps. Also save the output in the /output folder.<br><br>## 3. Create a package mapping using rules/package-mapping-rules.md and remember this mapping for the next steps. Also save the output in the /output folder.<br><br>## 4. Create a very basic target application in quarkus framework using rules/quarkus-rules.md and following the package mapping structure as applicable <br><br>## 5. Iterate through the following steps for each migration artifact identified under rules/analyze.md<br>    ## 5A. Migrate the artifact using rules/package-mapping-rules.md  and rules/quarkus-rules.md. Make sure to create complete test coverage for the migrated artifacts.<br>    ## 5B. Build the quarkus application and fix any build errors. Run `mvn quarkus:dev` command from the target project home directory in a terminal to build the quarkus project. <br>    ## 5C. Test the migrated artifact<br>    ## 5C. If the tests or the build fails, make fixes in the target code and repeat from step 5B<br>    ## 5D. If the artifact is migrated correctly, move to the next artifact<br>    ## 5E. If all artifacts are migrated correctly, move to step 6<br><br>## 6. Review the migrated code<br>    ## 6A. If there are any issues, make fixes in the target code and repeat from step 5B<br>    ## 6B. If there are no issues, move to step 7<br><br>## 7. create documentation</pre><p><strong>analyze.md</strong></p><pre># Analyze the source spring application<br><br>* Identify what this service does functionally <br>* Identify the runtime dependencies and external services it uses<br>* Identify the data models and entities it works with<br>* Identify if there are other organization specific packages/libraries this code depends on for compilation  <br>* Identify Spring Boot version and spring specific dependencies i.e.<br>  * REST API endpoints <br>  * Dependency injection that requires refactoring in Quarkus<br>  * Database connections using spring<br>  * External API calls using spring<br>  * Security configurations using spring<br>  * Logging and monitoring using spring <br>  * Testing dependencies using spring<br>  * Build and deployment configurations that uses spring<br>* Analyse the test cases to identify the test coverage<br>* Analyse the build and deployment configurations to identify the build and deployment process<br><br># Based on the analysis determine an order in which each artifact of the code should be migrated to Quarkus<br><br>* create dependency mapping using the dependency-mapping.md file<br>* The migration order should take into account an approach such that the target quarkus application can be compiled and tested at each step. <br>* Remember this order for rest of the steps</pre><p><strong>dependency-mapping.md</strong></p><pre># Spring Boot → Quarkus Dependency Map<br><br>Purpose: Track dependency replacements from Spring Boot to Quarkus<br><br>---<br><br>## 1. How to use this file<br><br>For each Spring dependency:<br>- mark the target Quarkus dependency or extension<br>- classify the mapping status<br>- note whether the migration path is:<br>    - **Mode B - Native Quarkus migration**<br>    - **Mode A - Fast compatibility migration**<br>    - **Mode C - Manual review required**<br>- capture any behavior risk<br><br>### Status values<br>- `mapped` = clear target dependency exists<br>- `compatibility` = use Quarkus Spring compatibility extension<br>- `manual-review` = no safe 1:1 dependency mapping<br>- `drop` = dependency not needed in target<br>- `defer` = keep for later decision<br><br>---<br><br>## 2. Core BOM and build structure<br><br>## 2.1 Parent and BOM mapping<br><br>| Spring source                     | Quarkus target                                       | Status | Notes                                                                   |<br>|-----------------------------------|------------------------------------------------------|--------|-------------------------------------------------------------------------|<br>| `spring-boot-starter-parent`      | Quarkus platform BOM                                 | mapped | Quarkus uses BOM/import management rather than Spring Boot parent style |<br>| Spring Boot dependency management | Quarkus platform coordinates in dependencyManagement | mapped | Align all Quarkus extensions to same platform                           |<br>| Spring Boot Maven plugin          | Quarkus Maven plugin                                 | mapped | Build workflow changes                                                  |<br>| Spring Boot Gradle plugin         | Quarkus Gradle plugin                                | mapped | Only if using Gradle                                                    |<br><br>### Rules<br>- Do not copy Spring Boot parent or starter assumptions directly<br>- Use a Quarkus platform-aligned dependency model<br>- Keep versions centralized through the Quarkus platform where possible<br><br>---<br><br>## 3. Web and REST<br><br>| Spring dependency             | Preferred Quarkus target                | Status        | Migration mode | Notes                                              |<br>|-------------------------------|-----------------------------------------|---------------|----------------|----------------------------------------------------|<br>| `spring-boot-starter-web`     | `quarkus-rest` + JSON support as needed | mapped        | native         | Preferred REST stack                               |<br>| `spring-webmvc`               | `quarkus-rest`                          | mapped        | native         | Rewrite annotations to Jakarta REST / Quarkus REST |<br>| `spring-boot-starter-webflux` | reactive Quarkus stack only if needed   | manual-review | native         | Not a blind replacement                            |<br>| Spring MVC annotations        | `quarkus-spring-web`                    | compatibility | compatibility  | Fast migration path                                |<br>| Jackson via Spring starter    | Quarkus JSON extension                  | mapped        | native         | Confirm serializers/modules                        |<br><br>### Rules<br>- Prefer `quarkus-rest` for final-state code<br>- Use `quarkus-spring-web` only to reduce migration churn<br>- Review `ResponseEntity`, exception handling, and content negotiation carefully<br><br>---<br><br>## 4. Dependency injection and bean model<br><br>| Spring dependency / pattern                                     | Preferred Quarkus target | Status        | Migration mode | Notes                                      |<br>|-----------------------------------------------------------------|--------------------------|---------------|----------------|--------------------------------------------|<br>| `spring-beans` usage                                            | CDI / ArC                | mapped        | native         | Prefer CDI bean model                      |<br>| Spring DI annotations                                           | `quarkus-spring-di`      | compatibility | compatibility  | Good transitional path                     |<br>| `@Autowired`, `@ComponentScan`, related bean wiring assumptions | CDI / ArC rewrite        | mapped        | native         | Some advanced wiring needs manual review   |<br>| AOP-heavy Spring bean model                                     | manual redesign          | manual-review | manual-review  | Check proxies, aspects, conditional wiring |<br><br>### Rules<br>- Prefer native CDI in final target code<br>- Treat bean post-processors, custom scopes, and advanced wiring as manual review<br>- ArC is not equivalent to the full Spring container model<br><br>---<br><br>## 5. Validation<br><br>| Spring dependency                 | Quarkus target                          | Status        | Migration mode | Notes                                     |<br>|-----------------------------------|-----------------------------------------|---------------|----------------|-------------------------------------------|<br>| `spring-boot-starter-validation`  | `quarkus-hibernate-validator`           | mapped        | native         | Straightforward                           |<br>| Jakarta validation annotations    | same                                    | mapped        | native         | Preserve DTO constraints                  |<br>| Spring method validation patterns | review with Quarkus validation behavior | manual-review | native         | Confirm service-level validation behavior |<br><br>---<br><br>## 6. Data access and persistence<br><br>| Spring dependency              | Preferred Quarkus target              | Status        | Migration mode | Notes                             |<br>|--------------------------------|---------------------------------------|---------------|----------------|-----------------------------------|<br>| `spring-boot-starter-data-jpa` | `quarkus-hibernate-orm` + JDBC driver | mapped        | native         | Native JPA path                   |<br>| Spring Data JPA repositories   | `quarkus-spring-data-jpa`             | compatibility | compatibility  | Fastest repository migration path |<br>| `spring-boot-starter-jdbc`     | `quarkus-jdbc-*` + datasource config  | mapped        | native         | Review SQL and tx behavior        |<br>| `spring-jdbc` helper patterns  | manual rewrite or plain JPA/JDBC      | manual-review | native         | Depends on usage style            |<br>| Hibernate core through Spring  | Quarkus Hibernate ORM                 | mapped        | native         | Re-check ORM config keys          |<br>| Flyway via Spring Boot         | Quarkus Flyway extension              | mapped        | native         | Confirm migration lifecycle       |<br>| Liquibase via Spring Boot      | Quarkus Liquibase extension           | mapped        | native         | Confirm startup behavior          |<br><br>### Rules<br>- For quick migration, use Spring Data JPA compatibility<br>- For longer-term design, move to standard JPA or Panache only where it helps<br>- Do not switch to Panache automatically during migration<br><br>---<br><br>## 7. Transactions<br><br>| Spring dependency / feature              | Quarkus target                             | Status        | Migration mode | Notes                          |<br>|------------------------------------------|--------------------------------------------|---------------|----------------|--------------------------------|<br>| Spring transaction management            | Jakarta Transactions / Narayana JTA        | mapped        | native         | Preserve boundaries carefully  |<br>| `@Transactional`                         | `@Transactional`                           | mapped        | native         | Usually direct                 |<br>| advanced propagation / rollback behavior | explicit review                            | manual-review | native         | Do not assume edge-case parity |<br>| `TransactionTemplate`                    | redesign / explicit transactional approach | manual-review | native         | Usually manual rewrite         |<br><br>---<br><br>## 8. Scheduling<br><br>| Spring dependency / feature      | Preferred Quarkus target                                    | Status        | Migration mode | Notes                                   |<br>|----------------------------------|-------------------------------------------------------------|---------------|----------------|-----------------------------------------|<br>| Spring scheduling                | Quarkus scheduler                                           | mapped        | native         | Preferred for final-state               |<br>| `@Scheduled` with minimal change | `quarkus-spring-scheduled`                                  | compatibility | compatibility  | Good transitional path                  |<br>| Quartz in Spring                 | Quarkus Quartz if clustered or persistent scheduling needed | mapped        | native         | Review clustering and misfire semantics |<br><br>### Rules<br>- Review concurrency behavior explicitly<br>- Review timezone, cron syntax, retry, and cluster behavior<br>- Do not assume scheduling semantics are identical<br><br>---<br><br>## 9. Caching<br><br>| Spring dependency / feature       | Preferred Quarkus target                  | Status        | Migration mode | Notes                                      |<br>|-----------------------------------|-------------------------------------------|---------------|----------------|--------------------------------------------|<br>| `spring-boot-starter-cache`       | `quarkus-cache`                           | mapped        | native         | Default backend is Caffeine                |<br>| Spring cache annotations retained | compatibility only if deliberately chosen | compatibility | compatibility  | Review key generation behavior             |<br>| distributed cache assumptions     | Redis / Infinispan strategy review        | manual-review | native         | Review topology and invalidation semantics |<br><br>### Rules<br>- Validate cache key behavior<br>- Validate null caching and eviction behavior<br>- Validate whether local vs distributed cache is acceptable<br><br>---<br><br>## 10. Security<br><br>| Spring dependency                        | Preferred Quarkus target                      | Status        | Migration mode | Notes                                     |<br>|------------------------------------------|-----------------------------------------------|---------------|----------------|-------------------------------------------|<br>| `spring-boot-starter-security`           | Quarkus security extensions                   | manual-review | native         | No blind 1:1                              |<br>| `spring-security-oauth2-resource-server` | Quarkus OIDC / JWT                            | manual-review | native         | Review authentication/authorization flows |<br>| `spring-security-oauth2-client`          | Quarkus OIDC client-related approach          | manual-review | native         | Review login/token flows                  |<br>| Spring method security                   | Quarkus security annotations / policy rewrite | manual-review | native         | Review role mapping                       |<br>| custom filters / entry points            | Quarkus HTTP/security handlers                | manual-review | native         | Often manual rewrite                      |<br><br>### Rules<br>- Treat security migration as high-risk<br>- Do not declare parity without tests for authn, authz, token handling, and headers<br><br>---<br><br>## 11. HTTP clients and integration clients<br><br>| Spring dependency / pattern           | Preferred Quarkus target                | Status        | Migration mode | Notes                         |<br>|---------------------------------------|-----------------------------------------|---------------|----------------|-------------------------------|<br>| `RestTemplate`                        | Quarkus REST Client                     | manual-review | native         | Manual rewrite                |<br>| Spring WebClient                      | Quarkus reactive / REST client strategy | manual-review | native         | Depends on interaction style  |<br>| OpenFeign                             | Quarkus REST Client approach            | manual-review | native         | Review retry, headers, auth   |<br>| Apache HttpClient via Spring wrappers | explicit Quarkus client strategy        | manual-review | native         | Confirm timeouts/interceptors |<br><br>---<br><br>## 12. Configuration and property binding<br><br>| Spring dependency / pattern           | Preferred Quarkus target | Status        | Migration mode | Notes                        |<br>|---------------------------------------|--------------------------|---------------|----------------|------------------------------|<br>| `@ConfigurationProperties` support    | `@ConfigMapping`         | mapped        | native         | Preferred structured config  |<br>| `@Value` property injection           | `@ConfigProperty`        | mapped        | native         | Good for simple values       |<br>| Spring property binding compatibility | use only when necessary  | compatibility | compatibility  | Prefer explicit mapping      |<br>| profile-specific property files       | Quarkus profile config   | mapped        | native         | Review naming and activation |<br><br>### Rules<br>- Prefer `@ConfigMapping` over scattered property lookups<br>- Build an explicit property map for every module<br>- Do not copy Spring property keys blindly<br><br>---<br><br>## 13. Testing<br><br>| Spring test dependency / pattern | Quarkus target                          | Status        | Migration mode | Notes                           |<br>|----------------------------------|-----------------------------------------|---------------|----------------|---------------------------------|<br>| `spring-boot-starter-test`       | `quarkus-junit5` + related test support | mapped        | native         | Tests need deliberate migration |<br>| `@SpringBootTest`                | `@QuarkusTest`                          | mapped        | native         | Common top-level mapping        |<br>| `@MockBean`                      | `@InjectMock` / Quarkus mocking         | mapped        | native         | Review injection style          |<br>| MockMvc                          | REST-assured / Quarkus test HTTP style  | manual-review | native         | Rewrite test idiom              |<br>| Spring slice tests               | Quarkus-focused test redesign           | manual-review | native         | No blind mapping                |<br><br>### Rules<br>- Tests must prove behavior parity, not just compile<br>- Preserve JSON, status code, validation, and security assertions<br><br>---<br><br>## 14. Health, metrics, OpenAPI, and observability<br><br>| Spring dependency / feature    | Quarkus target                         | Status        | Migration mode | Notes                             |<br>|--------------------------------|----------------------------------------|---------------|----------------|-----------------------------------|<br>| `spring-boot-starter-actuator` | split into specific Quarkus extensions | mapped        | native         | No single identical starter       |<br>| Actuator health                | `quarkus-smallrye-health`              | mapped        | native         | Path/payload may differ           |<br>| metrics / micrometer setup     | Quarkus metrics strategy               | manual-review | native         | Review existing consumers         |<br>| Springdoc OpenAPI              | `quarkus-smallrye-openapi`             | mapped        | native         | Review generated spec differences |<br>| tracing / Sleuth-like setup    | Quarkus OpenTelemetry strategy         | manual-review | native         | Review exporters and propagation  |<br><br>---<br><br>## 15. Messaging and integration<br><br>| Spring dependency / feature | Preferred Quarkus target                    | Status        | Migration mode | Notes                         |<br>|-----------------------------|---------------------------------------------|---------------|----------------|-------------------------------|<br>| Spring Kafka                | Quarkus Kafka / reactive messaging strategy | manual-review | native         | Review programming model      |<br>| Spring AMQP / Rabbit        | Quarkus messaging approach                  | manual-review | native         | Review topology/ack semantics |<br>| JMS starters                | Quarkus JMS/provider-specific approach      | manual-review | native         | Check provider support        |<br>| Spring Cloud Stream         | manual redesign                             | manual-review | native         | No blind mapping              |<br><br>### Rules<br>- Review delivery guarantees, retry, DLQ, serialization, and tracing<br><br>---<br><br>## 16. Cloud and Spring ecosystem features<br><br>| Spring ecosystem feature         | Quarkus target                              | Status        | Notes                             |<br>|----------------------------------|---------------------------------------------|---------------|-----------------------------------|<br>| Spring Cloud Config              | manual review / alternative config approach | manual-review | Re-architecture likely            |<br>| Eureka / discovery               | manual review                               | manual-review | Depends on runtime platform       |<br>| Spring Gateway                   | manual review                               | manual-review | Usually different architecture    |<br>| Resilience4j via Spring wrappers | Quarkus fault tolerance strategy            | manual-review | Review annotations and semantics  |<br>| Spring Batch                     | manual review                               | manual-review | Treat as separate migration track |<br><br>---<br><br>## 17. Common drop-or-rethink dependencies<br><br>| Spring / legacy dependency                        | Target action                                       | Status        | Notes                           |<br>|---------------------------------------------------|-----------------------------------------------------|---------------|---------------------------------|<br>| unnecessary starters pulling transitive libraries | remove and replace with explicit Quarkus extensions | drop          | Quarkus favors explicitness     |<br>| duplicate JSON libs pulled only through starters  | rationalize                                         | manual-review | Avoid conflicting serializers   |<br>| devtools                                          | use Quarkus dev mode instead                        | mapped        | Different developer workflow    |<br>| embedded servlet container assumptions            | rethink around Quarkus HTTP model                   | manual-review | Review if servlet APIs are used |<br><br>---<br><br>## 18. Dependency worksheet template<br><br>Use this per migrated module:<br><br>| Source dependency              | Source purpose               | Target dependency / extension | Status        | Migration mode | Risk       | Notes                   |<br>|--------------------------------|------------------------------|-------------------------------|---------------|----------------|------------|-------------------------|<br>| `spring-boot-starter-web`      | REST endpoints               | `quarkus-rest`                | mapped        | native         | medium     | check exception mapping |<br>| `spring-boot-starter-data-jpa` | persistence                  | `quarkus-hibernate-orm`       | mapped        | native         | medium     | check tx + lazy loading |<br>| Spring Data repository pattern | repository abstraction       | `quarkus-spring-data-jpa`     | compatibility | compatibility  | low-medium | phase-1 migration       |<br>| `spring-boot-starter-security` | authentication/authorization | Quarkus security stack        | manual-review | native         | high       | no blind rewrite        |<br><br>---<br><br>## 19. Final rules for this workspace<br><br>- Prefer native Quarkus dependencies in final-state code<br>- Use compatibility extensions only to reduce migration risk materially<br>- Record every non-trivial dependency decision<br>- Treat security, messaging, scheduling, caching, and HTTP client dependencies as explicit review areas<br>- Do not copy Spring starters into target assumptions</pre><p><strong>migration-rules.md</strong></p><pre># Spring Boot → Quarkus Mapping Reference<br><br>Purpose: defines a migration strategy and rules for spring to quarkus migration<br><br>---<br><br>## 1. How to use this file<br><br>This file defines the preferred migration rules for this workspace.<br><br>For each source classes, classify the migration into one of 3 paths:<br><br>1. **Mode B - Native Quarkus migration**<br>    - Use Quarkus / Jakarta / MicroProfile idioms directly<br>    - Best long-term target<br><br>2. **Mode A - Fast compatibility migration**<br>    - Use Quarkus Spring compatibility extensions temporarily<br>    - Good for faster migration or phased conversion<br><br>3. **Mode C - Manual review required**<br>    - No safe 1:1 mapping<br>    - Must be reviewed before generating final target code<br><br>---<br><br>## 2. Migration strategy modes<br><br>### Mode A — Fast compatibility migration<br>Use Quarkus Spring compatibility extensions where possible:<br>- Spring DI compatibility<br>- Spring Web compatibility<br>- Spring Data JPA compatibility<br>- Spring Scheduled compatibility<br><br>This approach is chosen if Mode-B requires too much refactoring in the first attempt. <br><br>### Mode B — Native Quarkus migration<br>Convert to:<br>- Jakarta REST / Quarkus REST<br>- CDI / ArC<br>- SmallRye Config / `@ConfigMapping`<br>- Quarkus testing model<br>- Quarkus scheduler / cache / security APIs<br><br>This is preferred approach as long as can be implemented with small changes in each iteration. <br><br>### Recommended rule for this workspace<br>- Prefer **Mode B — Native Quarkus migration** for new generated target code<br>- Use **Mode A — Fast compatibility migration** only when:<br>    - it materially reduces risk<br>    - the source feature is heavily Spring-specific<br>    - a direct native conversion would create excessive churn<br><br>---<br><br>## 3. High-level technology mapping<br><br>| Spring Boot area     | Preferred Quarkus target                       | Compatibility option                              | Notes                                            |<br>|----------------------|------------------------------------------------|---------------------------------------------------|--------------------------------------------------|<br>| Dependency Injection | CDI / ArC                                      | Spring DI extension                               | Prefer CDI in final target                       |<br>| REST API             | Quarkus REST / Jakarta REST                    | Spring Web extension                              | Prefer Quarkus REST in final target              |<br>| Validation           | Hibernate Validator / Jakarta Validation       | same                                              | Usually straightforward                          |<br>| Transactions         | Jakarta Transactions / Narayana JTA            | same                                              | Preserve transaction boundaries carefully        |<br>| Config binding       | `@ConfigMapping`, `@ConfigProperty`            | Spring Boot properties compatibility where needed | Prefer explicit config mapping                   |<br>| Data access          | Hibernate ORM / Panache or JPA                 | Spring Data JPA extension                         | Panache is optional, not required                |<br>| Scheduling           | Quarkus Scheduler / Quartz if clustered        | Spring Scheduled extension                        | Review concurrency semantics                     |<br>| Caching              | Quarkus Cache                                  | Spring Cache compatibility if retained            | Default backend is Caffeine                      |<br>| OpenAPI              | SmallRye OpenAPI                               | N/A                                               | Replace Springdoc as needed                      |<br>| Testing              | `@QuarkusTest`, component tests, `@InjectMock` | N/A                                               | Rework tests deliberately                        |<br>| Health               | SmallRye Health                                | N/A                                               | Replace Actuator health endpoints                |<br>| Metrics              | Quarkus metrics extension(s)                   | N/A                                               | Review existing observability needs              |<br>| External REST client | Quarkus REST Client                            | N/A                                               | Replace `RestTemplate` / Feign patterns manually |<br>| Security             | Quarkus Security / OIDC / JWT                  | Spring Security compatibility in some cases       | Must review per use case                         |<br><br>---<br><br>## 4. Dependency mapping<br><br>## 4.1 Core platform<br><br>| Spring Boot dependency                       | Preferred Quarkus dependency / extension                  | Notes                                                  |<br>|----------------------------------------------|-----------------------------------------------------------|--------------------------------------------------------|<br>| `spring-boot-starter`                        | Quarkus BOM + core extensions                             | Quarkus is extension-driven rather than starter-driven |<br>| `spring-boot-starter-web`                    | `quarkus-rest`, JSON extension as needed                  | Prefer Quarkus REST                                    |<br>| `spring-boot-starter-validation`             | `quarkus-hibernate-validator`                             | Direct mapping                                         |<br>| `spring-boot-starter-data-jpa`               | `quarkus-hibernate-orm`, JDBC driver                      | Or use Spring Data JPA compatibility                   |<br>| `spring-boot-starter-jdbc`                   | `quarkus-jdbc-*`, datasource config                       | Review transaction semantics                           |<br>| `spring-boot-starter-test`                   | `quarkus-junit5`, Mockito support as needed               | Tests usually need explicit migration                  |<br>| `spring-boot-starter-actuator`               | `quarkus-smallrye-health`, metrics / telemetry extensions | Split features explicitly                              |<br>| `spring-boot-starter-cache`                  | `quarkus-cache`                                           | Review backend and key semantics                       |<br>| `spring-boot-starter-security`               | Quarkus security extensions                               | Manual review usually required                         |<br>| `spring-boot-starter-oauth2-resource-server` | Quarkus OIDC / JWT extensions                             | Manual review required                                 |<br>| `spring-boot-starter-oauth2-client`          | Quarkus OIDC client-related extensions                    | Manual review required                                 |<br>| `spring-boot-starter-webflux`                | Quarkus reactive stack only if truly needed               | Not a blind 1:1 replacement                            |<br><br>## 4.2 Compatibility dependencies<br><br>| Spring feature retained      | Quarkus compatibility extension |<br>|------------------------------|---------------------------------|<br>| Spring DI annotations        | `quarkus-spring-di`             |<br>| Spring Web annotations       | `quarkus-spring-web`            |<br>| Spring Data JPA repositories | `quarkus-spring-data-jpa`       |<br>| Spring Scheduled             | `quarkus-spring-scheduled`      |<br><br>## 4.3 Observability and docs<br><br>| Spring ecosystem           | Quarkus target                          |<br>|----------------------------|-----------------------------------------|<br>| Springdoc OpenAPI          | `quarkus-smallrye-openapi`              |<br>| Actuator health            | `quarkus-smallrye-health`               |<br>| Micrometer / metrics setup | review current Quarkus metrics strategy |<br>| Sleuth / tracing           | review Quarkus OpenTelemetry strategy   |<br><br>---<br><br>## 5. Annotation mapping<br><br>## 5.1 Dependency injection and bean lifecycle<br><br>| Spring            | Preferred Quarkus                          | Compatibility                                | Notes                                          |<br>|-------------------|--------------------------------------------|----------------------------------------------|------------------------------------------------|<br>| `@Component`      | `@ApplicationScoped` or other CDI scope    | keep via Spring DI extension only if needed  | Choose scope deliberately                      |<br>| `@Service`        | `@ApplicationScoped`                       | Spring DI extension                          | Usually `@ApplicationScoped`                   |<br>| `@Repository`     | `@ApplicationScoped`                       | Spring DI extension                          | Persistence exception translation needs review |<br>| `@Controller`     | `@Path` endpoint or MVC equivalent pattern | Spring Web extension                         | Usually become REST resources in API services  |<br>| `@RestController` | `@Path` + response annotations / JSON      | Spring Web extension                         | Prefer Jakarta REST                            |<br>| `@Autowired`      | `@Inject`                                  | Spring DI extension                          | Prefer constructor injection                   |<br>| `@Qualifier`      | `@Named` / CDI qualifier                   | Spring DI extension                          | Custom qualifier rewrite may be needed         |<br>| `@Primary`        | CDI alternatives / explicit qualifiers     | Spring DI extension                          | Manual review often needed                     |<br>| `@PostConstruct`  | `@PostConstruct`                           | same                                         | Usually direct                                 |<br>| `@PreDestroy`     | `@PreDestroy`                              | same                                         | Usually direct                                 |<br>| `@Lazy`           | manual review                              | maybe compatibility only                     | Review lifecycle assumptions                   |<br>| `@Value`          | `@ConfigProperty`                          | Spring properties compatibility where needed | Prefer structured config                       |<br><br>### Scope mapping guidance<br><br>| Spring scope | Quarkus / CDI target | Notes                                        |<br>|--------------|----------------------|----------------------------------------------|<br>| singleton    | `@ApplicationScoped` | Most common mapping                          |<br>| prototype    | `@Dependent`         | Review lifecycle expectations                |<br>| request      | `@RequestScoped`     | Common web-scoped mapping                    |<br>| session      | manual review        | Depends on app model and HTTP session design |<br><br>---<br><br>## 5.2 REST endpoint annotations<br><br>| Spring MVC          | Preferred Quarkus REST                        | Compatibility        | Notes                              |<br>|---------------------|-----------------------------------------------|----------------------|------------------------------------|<br>| `@RestController`   | `@Path` + REST resource class                 | Spring Web extension | Prefer native Quarkus REST         |<br>| `@RequestMapping`   | `@Path`                                       | Spring Web extension | Method/path decomposition required |<br>| `@GetMapping`       | `@GET` + `@Path`                              | Spring Web extension | Direct concept mapping             |<br>| `@PostMapping`      | `@POST` + `@Path`                             | Spring Web extension | Direct concept mapping             |<br>| `@PutMapping`       | `@PUT` + `@Path`                              | Spring Web extension | Direct concept mapping             |<br>| `@DeleteMapping`    | `@DELETE` + `@Path`                           | Spring Web extension | Direct concept mapping             |<br>| `@PatchMapping`     | `@PATCH` + `@Path`                            | Spring Web extension | Confirm media type semantics       |<br>| `@RequestBody`      | body parameter                                | Spring Web extension | Preserve JSON contract             |<br>| `@PathVariable`     | `@PathParam`                                  | Spring Web extension | Preserve names exactly             |<br>| `@RequestParam`     | `@QueryParam`                                 | Spring Web extension | Preserve required/default rules    |<br>| `@RequestHeader`    | `@HeaderParam`                                | Spring Web extension | Preserve case/required rules       |<br>| `@ResponseStatus`   | explicit `Response` or framework behavior     | Spring Web extension | Review default codes               |<br>| `ResponseEntity&lt;T&gt;` | `Response` or direct return type              | N/A                  | Choose case-by-case                |<br>| `@ControllerAdvice` | `ExceptionMapper` / global exception handling | N/A                  | Manual rewrite usually needed      |<br>| `@ExceptionHandler` | `ExceptionMapper`                             | N/A                  | Preserve status/body carefully     |<br>| `@CrossOrigin`      | Quarkus CORS config / filter strategy         | N/A                  | Review globally vs per-endpoint    |<br><br>### REST conversion rules<br>- Preserve:<br>    - route path<br>    - HTTP method<br>    - media types<br>    - request and response DTOs<br>    - status code behavior<br>    - validation behavior<br>    - exception body structure<br>- Do not silently change:<br>    - `ResponseEntity` semantics<br>    - null/empty response handling<br>    - pagination defaults<br>    - error envelope structure<br><br>---<br><br>## 5.3 Validation annotations<br><br>| Spring / Jakarta Validation usage      | Quarkus target                                                    | Notes                                  |<br>|----------------------------------------|-------------------------------------------------------------------|----------------------------------------|<br>| `@Valid`                               | `@Valid`                                                          | Direct                                 |<br>| `@Validated`                           | usually keep validation intent, may need method validation review | Review service-layer method validation |<br>| `@NotNull`, `@NotBlank`, `@Size`, etc. | same Jakarta validation annotations                               | Direct                                 |<br>| Binding / validation error handling    | Quarkus validation + exception mapping                            | Review error payload parity            |<br><br>### Validation rules<br>- Preserve DTO field constraints exactly<br>- Preserve method parameter validation where used<br>- Confirm HTTP 400 / error response behavior<br>- Review custom validators and groups manually<br><br>---<br><br>## 5.4 Transactions<br><br>| Spring                | Quarkus                                             | Notes                                                    |<br>|-----------------------|-----------------------------------------------------|----------------------------------------------------------|<br>| `@Transactional`      | `@Transactional` (Jakarta Transactions)             | Common mapping                                           |<br>| propagation rules     | manual review against Jakarta transaction semantics | Do not assume identical edge-case behavior               |<br>| rollback rules        | manual review                                       | Explicit rollback policies should be checked             |<br>| `TransactionTemplate` | manual rewrite                                      | Usually refactor to declarative or explicit JTA approach |<br><br>### Transaction rules<br>- Preserve transaction boundaries around:<br>    - create/update/delete flows<br>    - outbox/event publication patterns<br>    - multi-repository write flows<br>- Review:<br>    - nested transaction assumptions<br>    - async boundaries<br>    - checked-exception rollback behavior<br>    - lazy loading behavior outside transaction<br><br>---<br><br>## 5.5 Scheduling<br><br>| Spring                           | Preferred Quarkus                       | Compatibility              | Notes                                                    |<br>|----------------------------------|-----------------------------------------|----------------------------|----------------------------------------------------------|<br>| `@Scheduled`                     | `@Scheduled` from Quarkus scheduler     | Spring Scheduled extension | Native preferred                                         |<br>| cron expressions                 | Quarkus scheduler / Quartz if clustered | Spring Scheduled extension | Confirm expression semantics                             |<br>| clustered scheduling             | Quartz extension                        | N/A                        | Needed for clustered coordination                        |<br>| concurrent execution assumptions | manual review                           | N/A                        | Quarkus scheduler allows concurrent execution by default |<br><br>### Scheduling rules<br>- Verify:<br>    - cron or interval equivalence<br>    - timezone handling<br>    - misfire / retry assumptions<br>    - concurrency behavior<br>    - clustered vs single-node intent<br><br>---<br><br>## 5.6 Caching<br><br>| Spring Cache         | Preferred Quarkus Cache                    | Compatibility                          | Notes                       |<br>|----------------------|--------------------------------------------|----------------------------------------|-----------------------------|<br>| `@Cacheable`         | `@CacheResult`                             | Spring cache compatibility if retained | Review key semantics        |<br>| `@CacheEvict`        | `@CacheInvalidate` / `@CacheInvalidateAll` | compatibility if retained              | Review invalidation breadth |<br>| `@CachePut`          | manual review / redesign                   | compatibility may help                 | Check write-through intent  |<br>| cache manager config | Quarkus cache config                       | compatibility may help                 | Default backend is Caffeine |<br><br>### Cache rules<br>- Review:<br>    - key generation differences<br>    - null caching behavior<br>    - TTL / eviction behavior<br>    - backend choice<br>    - distributed cache requirements<br><br>---<br><br>## 5.7 Configuration<br><br>### Property injection and binding<br><br>| Spring                                       | Preferred Quarkus                | Compatibility                                    | Notes                             |<br>|----------------------------------------------|----------------------------------|--------------------------------------------------|-----------------------------------|<br>| `@Value(&quot;${x.y}&quot;)`                           | `@ConfigProperty(name = &quot;x.y&quot;)`  | Spring Boot properties compatibility if retained | Prefer typed config               |<br>| `@ConfigurationProperties`                   | `@ConfigMapping(prefix = &quot;...&quot;)` | compatibility layer only if needed               | Preferred structured mapping      |<br>| `Environment` access                         | config injection / mapping       | N/A                                              | Avoid scattered string lookups    |<br>| `application.yml` / `application.properties` | Quarkus config                   | N/A                                              | Explicit key mapping required     |<br>| Spring profiles                              | Quarkus profiles                 | N/A                                              | Review activation model and names |<br><br>### Config migration rules<br>- Create a property mapping table for every migrated module<br>- Mark each property as:<br>    - direct mapping<br>    - renamed mapping<br>    - manual review<br>    - deprecated / removed<br>- Preserve:<br>    - defaults<br>    - environment overrides<br>    - profile-specific values<br>    - secrets handling<br>    - feature toggles<br><br>### Suggested property mapping status template<br><br>| Source key                | Target key                         | Status        | Notes                         |<br>|---------------------------|------------------------------------|---------------|-------------------------------|<br>| `server.port`             | `quarkus.http.port`                | renamed       | verify env overrides          |<br>| `spring.application.name` | app naming strategy                | manual review | depends on usage              |<br>| `spring.datasource.*`     | `quarkus.datasource.*`             | renamed       | verify driver and tx settings |<br>| `spring.jpa.*`            | `quarkus.hibernate-orm.*`          | renamed       | verify semantics individually |<br>| `management.*`            | health/metrics/openapi equivalents | manual review | no blind 1:1 mapping          |<br><br>---<br><br>## 5.8 Data access<br><br>## Option 1 — Compatibility path<br>Keep repository model close to Spring:<br>- use Spring Data JPA compatibility extension<br>- keep repository interfaces where possible<br>- fastest migration path<br><br>## Option 2 — Native path<br>Convert to:<br>- standard JPA with CDI-managed repositories<br>- optionally Panache for simpler patterns<br><br>### Repository mapping<br><br>| Spring Data             | Preferred Quarkus target                  | Compatibility                  | Notes                                  |<br>|-------------------------|-------------------------------------------|--------------------------------|----------------------------------------|<br>| `JpaRepository&lt;T, ID&gt;`  | JPA repository bean or Panache repository | Spring Data JPA extension      | Compatibility is fastest               |<br>| `CrudRepository&lt;T, ID&gt;` | repository bean / Panache                 | Spring Data JPA extension      | Fine either way                        |<br>| derived query methods   | manual review or retain via compatibility | Spring Data JPA extension      | Good candidate for compatibility first |<br>| `@Query` JPQL/native    | manual port/review                        | Spring Data JPA extension      | Confirm query semantics                |<br>| paging and sorting      | manual review                             | compatibility may reduce churn | Verify API contract                    |<br>| projections             | manual review                             | compatibility may help         | Check serialization/use cases          |<br><br>### JPA entity mapping<br><br>| Spring / JPA usage               | Quarkus target                     | Notes                                 |<br>|----------------------------------|------------------------------------|---------------------------------------|<br>| `@Entity`                        | same                               | Direct                                |<br>| `@Table`                         | same                               | Direct                                |<br>| `@Id`, `@GeneratedValue`         | same                               | Direct                                |<br>| `@ManyToOne`, `@OneToMany`, etc. | same                               | Direct but review fetch/lazy use      |<br>| auditing annotations             | manual review                      | Spring Data auditing may need rewrite |<br>| entity listeners                 | usually portable but review wiring | Check lifecycle assumptions           |<br><br>### Data access review checklist<br>- lazy loading expectations<br>- transaction boundaries<br>- exception translation expectations<br>- pagination and sorting response format<br>- native query portability<br>- auditing behavior<br>- boot-time schema generation expectations<br><br>---<br><br>## 5.9 External HTTP clients<br><br>| Spring         | Preferred Quarkus                                 | Notes                |<br>|----------------|---------------------------------------------------|----------------------|<br>| `RestTemplate` | Quarkus REST Client                               | Manual rewrite       |<br>| `WebClient`    | Quarkus reactive / REST client strategy           | Depends on app model |<br>| OpenFeign      | review Quarkus REST Client / alternative patterns | Usually manual       |<br><br>### Client migration rules<br>- preserve:<br>    - base URL config<br>    - timeouts<br>    - interceptors / headers<br>    - auth propagation<br>    - retry/circuit breaker behavior<br>    - serialization behavior<br><br>---<br><br>## 5.10 Security<br><br>| Spring Security usage       | Quarkus target                                 | Notes                       |<br>|-----------------------------|------------------------------------------------|-----------------------------|<br>| method security annotations | Quarkus security annotations / policy mapping  | Manual review               |<br>| OAuth2 resource server      | Quarkus OIDC / JWT                             | Manual review               |<br>| OAuth2 client               | Quarkus OIDC client approach                   | Manual review               |<br>| custom filters              | Quarkus filters / handlers / security pipeline | Manual rewrite often needed |<br>| form login / sessions       | manual review                                  | Depends on app type         |<br>| CORS/security headers       | Quarkus HTTP/security config                   | Review centrally            |<br><br>### Security migration rule<br>Security must be migrated module-by-module and reviewed explicitly.<br>Do not claim direct parity without checking:<br>- authentication flow<br>- authorization rules<br>- role mapping<br>- token propagation<br>- session behavior<br>- CSRF/CORS/header behavior<br><br>---<br><br>## 5.11 Testing<br><br>| Spring test style       | Quarkus target                         | Notes                            |<br>|-------------------------|----------------------------------------|----------------------------------|<br>| `@SpringBootTest`       | `@QuarkusTest`                         | Common top-level mapping         |<br>| sliced Spring tests     | Quarkus component / focused tests      | Manual redesign sometimes needed |<br>| `@MockBean`             | `@InjectMock` or Quarkus mock strategy | Review scope and injection model |<br>| MockMvc                 | REST-assured / Quarkus test HTTP style | Manual rewrite                   |<br>| test property overrides | Quarkus test config override options   | Review approach per test type    |<br><br>### Testing migration rules<br>- rewrite tests to prove parity, not just compile<br>- preserve:<br>    - status code assertions<br>    - JSON shape assertions<br>    - validation assertions<br>    - security assertions<br>    - transaction / persistence assertions<br>- add explicit regression tests for:<br>    - exception mapping<br>    - serialization formats<br>    - profile-specific config<br>    - scheduled job behavior<br>    - cache behavior where important<br><br>---<br><br>## 5.12 OpenAPI / API docs<br><br>| Spring ecosystem          | Quarkus target                             | Notes                             |<br>|---------------------------|--------------------------------------------|-----------------------------------|<br>| Springdoc / Swagger setup | SmallRye OpenAPI + Swagger UI              | Review path/customization         |<br>| annotation-driven OpenAPI | MicroProfile OpenAPI annotations as needed | Review generated spec differences |<br><br>---<br><br>## 5.13 Health / management endpoints<br><br>| Spring Actuator                    | Quarkus target                     | Notes                         |<br>|------------------------------------|------------------------------------|-------------------------------|<br>| `/actuator/health`                 | SmallRye Health endpoints          | Path and payload may differ   |<br>| readiness / liveness               | SmallRye Health readiness/liveness | Common mapping                |<br>| info / custom management endpoints | manual review                      | Rebuild only needed endpoints |<br>| metrics                            | Quarkus metrics strategy           | Review consumer expectations  |<br><br>---<br><br>## 6. Source-to-target folder mapping rules<br><br>| Source location                                      | Target location                                                                        |<br>|------------------------------------------------------|----------------------------------------------------------------------------------------|<br>| `spring-src/&lt;repo&gt;/src/main/java/.../controller/*`   | `quarkus-out/&lt;repo&gt;/src/main/java/.../api/*` or matching package                       |<br>| `spring-src/&lt;repo&gt;/src/main/java/.../service/*`      | `quarkus-out/&lt;repo&gt;/src/main/java/.../service/*`                                       |<br>| `spring-src/&lt;repo&gt;/src/main/java/.../repository/*`   | `quarkus-out/&lt;repo&gt;/src/main/java/.../repository/*`                                    |<br>| `spring-src/&lt;repo&gt;/src/main/java/.../config/*`       | `quarkus-out/&lt;repo&gt;/src/main/java/.../config/*`                                        |<br>| `spring-src/&lt;repo&gt;/src/main/resources/application.*` | `quarkus-out/&lt;repo&gt;/src/main/resources/application.properties` or chosen target config |<br>| `spring-src/&lt;repo&gt;/src/test/java/...`                | `quarkus-out/&lt;repo&gt;/src/test/java/...`                                                 |<br><br>### Package naming rule<br>- Keep package names stable unless there is a strong reason to change them<br>- If controllers become resources, package rename such as `controller` → `api` is acceptable<br>- Record any non-trivial package rename in `mapping/package-map.md`<br><br>---<br><br>## 7. Risk classes<br><br>### Low-risk mappings<br>Usually straightforward:<br>- JPA entity annotations<br>- validation annotations<br>- simple CDI injection<br>- simple REST endpoints<br>- basic config injection<br><br>### Medium-risk mappings<br>Need review:<br>- `ResponseEntity`<br>- exception handling<br>- repository derived queries<br>- pagination/sorting<br>- scheduled jobs<br>- caching<br>- OpenAPI generation changes<br><br>### High-risk mappings<br>Manual review required:<br>- Spring Security<br>- Spring Cloud patterns<br>- Feign / `RestTemplate` rewrites<br>- transaction propagation edge cases<br>- custom bean lifecycle tricks<br>- conditional beans<br>- reflection-heavy frameworks<br>- AOP-heavy behavior<br>- actuator custom endpoints<br>- eventing / async workflows<br>- session-heavy MVC apps<br><br>---<br><br>## 8. Manual review required list<br><br>Always flag these for explicit human review:<br><br>- `@ControllerAdvice`<br>- `@ExceptionHandler`<br>- `ResponseEntity` with complex status/header logic<br>- `@Primary`<br>- custom `BeanPostProcessor`<br>- Spring AOP aspects<br>- conditional bean creation (`@Conditional*`)<br>- Spring Security config<br>- method-level security<br>- custom servlet filters / interceptors<br>- `RestTemplate`, Feign, WebClient integrations<br>- Spring Cloud Config, discovery, circuit breaker, gateway features<br>- Actuator custom endpoints<br>- Spring Batch<br>- WebFlux / Reactor-specific flows<br>- distributed scheduling assumptions<br>- distributed caching assumptions<br>- Spring Session<br>- Spring Events with complex transactional sequencing<br><br>---<br><br>## 9. Generation contract for agents<br><br>When converting any file, the generator must return:<br><br>1. **Source file path**<br>2. **Target file path**<br>3. **Mapping type**<br>    - native<br>    - compatibility<br>    - manual-review-assisted<br>4. **Key mapping summary**<br>5. **Known risks**<br>6. **Recommended tests**<br><br>---<br><br>## 10. Example conversion patterns<br><br>## 10.1 Controller<br><br>### Source<br>- `@RestController`<br>- `@RequestMapping(&quot;/customers&quot;)`<br>- `@GetMapping(&quot;/{id}&quot;)`<br><br>### Preferred target<br>- `@Path(&quot;/customers&quot;)`<br>- `@GET`<br>- `@Path(&quot;/{id}&quot;)`<br><br>### Checks<br>- path unchanged<br>- status code unchanged<br>- JSON unchanged<br>- validation unchanged<br>- exception handling unchanged<br><br>## 10.2 Service<br><br>### Source<br>- `@Service`<br>- constructor injection<br>- `@Transactional`<br><br>### Preferred target<br>- `@ApplicationScoped`<br>- constructor injection or CDI injection<br>- `@Transactional`<br><br>### Checks<br>- method signatures unchanged<br>- side effects unchanged<br>- rollback semantics reviewed<br><br>## 10.3 Config<br><br>### Source<br>- `@ConfigurationProperties(prefix = &quot;customer&quot;)`<br><br>### Preferred target<br>- `@ConfigMapping(prefix = &quot;customer&quot;)`<br><br>### Checks<br>- defaults preserved<br>- profile overrides preserved<br>- env overrides preserved<br><br>---<br><br>## 11. Property mapping worksheet template<br><br>Use this table per module:<br><br>| Source property                             | Target property                 | Type          | Status        | Default preserved | Profile reviewed | Notes            |<br>|---------------------------------------------|---------------------------------|---------------|---------------|-------------------|------------------|------------------|<br>| `server.port`                               | `quarkus.http.port`             | direct rename | mapped        | yes               | yes              |                  |<br>| `spring.datasource.url`                     | `quarkus.datasource.jdbc.url`   | rename        | mapped        | yes               | yes              | verify driver    |<br>| `spring.jpa.hibernate.ddl-auto`             | review target ORM config        | semantic      | manual review | TBD               | TBD              | confirm behavior |<br>| `management.endpoints.web.exposure.include` | health/metrics/openapi strategy | conceptual    | manual review | TBD               | TBD              | not direct       |<br><br>---<br><br>## 12. Decision log template<br><br>For any non-trivial mapping, record:<br><br>- Source construct:<br>- Source file:<br>- Target construct:<br>- Mapping type:<br>- Why chosen:<br>- Known risk:<br>- Tests added:<br>- Deferred cleanup:<br><br>---<br><br>## 13. Final rules for this workspace<br><br>- the original project folder is is read-only<br>- the newly created migrated project folder is the only target for generated code<br>- there should be no spring depdencies remaining in the migrated code <br>- Prefer Mode B — Native Quarkus migration for final-state code<br>- Use compatibility extensions only when they reduce migration risk materially<br>- Mark high-risk areas explicitly<br>- Never assume parity for security, transactions, scheduling, caching, or exception handling without tests</pre><p><strong>package-mapping.md</strong></p><pre># Spring Boot → Quarkus Package Map<br>Purpose: Track source-to-target package names, class names, file names and file placement from spring to quarkus migrated artifacts. <br><br>---<br><br>## 1. How to use this file<br><br>This file records where source packages and files from the Spring Boot application should land in the Quarkus target project.<br><br>Use it to:<br>- keep generated output consistent<br>- support traceability during conversion<br>- avoid random package naming drift<br>- make source-to-target mapping reviewable<br><br><br>For each package or file:<br>- record source location<br>- record target location<br>- classify whether the move is:<br>    - **same package**<br>    - **renamed package**<br>    - **restructured**<br>- explain why if not a straight carry-over<br><br>---<br><br>## 2. Default package mapping policy<br><br>### General rule<br>In the target insert `.quarkus.` in the package name just before the last part of the package name e.g. from `com.bank.ms.service1` to `com.bank.ms.quarkus.service1`<br>Also change `controller` to `api` as controller is a pure spring nomenclature<br>This will still maintain the original package structure and naming parity, and traceability. <br><br>### Recommended conventions<br>- keep domain, service, repository, config, and dto packages close to source<br>- do not invent a new package taxonomy during migration unless there is a real need to place a new class<br>- preserve module boundaries<br><br>### Allowed target naming choices<br>For REST-facing code, choose one convention and stay consistent:<br>- `...controller` → `...api`<br>- or `...controller` → `...resource`<br><br><br><br>---<br><br>## 3. Top-level source-to-target project mapping<br><br>Here is an example: <br>If the source project is under `spring-src`<br>and the target path is under `quarkus-out`<br><br>| Source project path                           | Target project path                            | Status | Notes                              |<br>|-----------------------------------------------|------------------------------------------------|--------|------------------------------------|<br>| `spring-src/&lt;source-repo&gt;/`                   | `quarkus-out/&lt;target-repo&gt;/`                   | mapped | One source repo to one target repo |<br>| `spring-src/&lt;source-repo&gt;/src/main/java`      | `quarkus-out/&lt;target-repo&gt;/src/main/java`      | mapped | Main source path                   |<br>| `spring-src/&lt;source-repo&gt;/src/main/resources` | `quarkus-out/&lt;target-repo&gt;/src/main/resources` | mapped | Config and resource migration      |<br>| `spring-src/&lt;source-repo&gt;/src/test/java`      | `quarkus-out/&lt;target-repo&gt;/src/test/java`      | mapped | Test migration                     |<br>| `spring-src/&lt;source-repo&gt;/src/test/resources` | `quarkus-out/&lt;target-repo&gt;/src/test/resources` | mapped | Review test config paths           |<br><br>---<br><br>## 4. Standard package mapping rules<br><br>| Source package pattern      | Target package pattern    | Status       | Notes                                               |<br>|-----------------------------|---------------------------|--------------|-----------------------------------------------------|<br>| `..controller..`            | `..api..`                 | renamed      | Recommended for Quarkus REST resources              |<br>| `..service..`               | `..service..`             | same-package | Preserve                                            |<br>| `..repository..`            | `..repository..`          | same-package | Preserve unless repository model is redesigned      |<br>| `..config..`                | `..config..`              | same-package | Preserve                                            |<br>| `..dto..`                   | `..dto..`                 | same-package | Preserve external contracts                         |<br>| `..entity..`                | `..entity..`              | same-package | Preserve                                            |<br>| `..model..`                 | `..model..`               | same-package | Preserve unless overloaded/ambiguous                |<br>| `..mapper..`                | `..mapper..`              | same-package | Preserve                                            |<br>| `..exception..`             | `..exception..`           | same-package | Preserve                                            |<br>| `..advice..`                | `..exception..` or review | restructured | Controller advice usually becomes exception mappers |<br>| `..client..`                | `..client..`              | same-package | Preserve but review implementation                  |<br>| `..scheduler..` / `..job..` | same or `..scheduler..`   | same-package | Keep intention explicit                             |<br>| `..security..`              | `..security..`            | same-package | Preserve package, but review contents carefully     |<br><br>---<br><br>## 5. File-level mapping rules<br><br>## 5.1 Controllers / endpoints<br><br>| Source file pattern         | Target file pattern                  | Status       | Notes                                 |<br>|-----------------------------|--------------------------------------|--------------|---------------------------------------|<br>| `*Controller.java`          | `*Resource.java` or `*Endpoint.java` | renamed      | Choose one suffix and stay consistent |<br>| package `..controller`      | package `..api`                      | renamed      | Recommended                           |<br>| `@ControllerAdvice` classes | `*ExceptionMapper.java`              | restructured | Manual rewrite usually needed         |<br><br>### Recommended workspace convention<br>- For package naming: `controller` → `api`<br>- For class name suffix: `Controller` → `Resource`<br><br>Example:<br>- `com.bank.customer.controller.CustomerController`<br>- becomes<br>- `com.bank.customer.api.CustomerResource`<br><br>---<br><br>## 5.2 Services<br><br>| Source file pattern | Target file pattern      | Status       | Notes                                                          |<br>|---------------------|--------------------------|--------------|----------------------------------------------------------------|<br>| `*Service.java`     | same filename by default | same-package | Preserve naming unless interface/impl split is being flattened |<br>| `*ServiceImpl.java` | same or simplified       | review       | Keep source traceability high                                  |<br><br>### Service rule<br>Preserve service names unless there is a strong reason to simplify them.<br><br>---<br><br>## 5.3 Repositories<br><br>| Source file pattern                         | Target file pattern                  | Status       | Notes                              |<br>|---------------------------------------------|--------------------------------------|--------------|------------------------------------|<br>| repository interfaces used with Spring Data | same filename if using compatibility | same-package | Fastest migration path             |<br>| repository beans rewritten to native JPA    | may remain same filename             | review       | Depends on implementation strategy |<br><br>### Repository rule<br>- If using `quarkus-spring-data-jpa`, keep names stable<br>- If moving to native repository beans, document any change clearly<br><br>---<br><br>## 5.4 Configuration classes<br><br>| Source file pattern | Target file pattern                                      | Status | Notes                                |<br>|---------------------|----------------------------------------------------------|--------|--------------------------------------|<br>| `*Config.java`      | same or split by concern                                 | review | Keep same where possible             |<br>| `*Properties.java`  | `*Config.java` / `*Configuration.java` / same class name | review | Depends on `@ConfigMapping` approach |<br><br>### Config rule<br>For `@ConfigurationProperties` migrations:<br>- keep config intent obvious<br>- target class name may stay the same if that helps traceability<br>- document prefix mapping explicitly<br><br>---<br><br>## 5.5 DTOs, entities, mappers<br><br>| Source file pattern                | Target file pattern | Status       | Notes                             |<br>|------------------------------------|---------------------|--------------|-----------------------------------|<br>| DTO classes                        | same                | same-package | Preserve external contract        |<br>| JPA entities                       | same                | same-package | Preserve ORM mapping              |<br>| MapStruct mappers / manual mappers | same                | same-package | Preserve if behavior is unchanged |<br><br>---<br><br>## 5.6 Clients and integrations<br><br>| Source file pattern    | Target file pattern        | Status       | Notes                                    |<br>|------------------------|----------------------------|--------------|------------------------------------------|<br>| `*Client.java`         | same or `*RestClient.java` | review       | Depends on Quarkus client approach       |<br>| Feign-style interfaces | manual review              | restructured | Often redesigned for Quarkus REST Client |<br><br>---<br><br>## 5.7 Scheduled jobs and background workers<br><br>| Source file pattern                          | Target file pattern | Status       | Notes                                        |<br>|----------------------------------------------|---------------------|--------------|----------------------------------------------|<br>| `*Scheduler.java`, `*Job.java`, `*Task.java` | same by default     | same-package | Preserve intent                              |<br>| Spring scheduling support files              | review              | review       | Depends on native vs compatibility migration |<br><br>---<br><br>## 6. Resources mapping<br><br>| Source resource               | Target resource                                                                                | Status | Notes                                          |<br>|-------------------------------|------------------------------------------------------------------------------------------------|--------|------------------------------------------------|<br>| `application.properties`      | `application.properties`                                                                       | same   | Map keys explicitly                            |<br>| `application.yml`             | refactor to properties file and rename to `application.properties` or retained config strategy | review | Quarkus commonly uses properties               |<br>| profile-specific config files | Quarkus profile-specific config                                                                | review | Preserve effective behavior                    |<br>| SQL migration files           | same relative location where tool expects                                                      | same   | Depends on Flyway/Liquibase choice             |<br>| static resources              | same if still needed                                                                           | review | Depends on app type                            |<br>| templates                     | manual review                                                                                  | review | Only relevant if server-side rendering is used |<br><br>---<br><br>## 7. Test package mapping<br>In general, follow the same rule as package naming rule above under section 2. Default package mapping policy<br><br>| Source test pattern | Target test pattern                                       | Status          | Notes                |<br>|---------------------|-----------------------------------------------------------|-----------------|----------------------|<br>| controller tests    | API/resource tests                                        | renamed         | Keep coverage intent |<br>| service tests       | append `quarkus` before the last part of the package name | updated package |                      |<br>| repository tests    | append `quarkus` before the last part of the package name | updated package |                      |<br>| MockMvc tests       | HTTP/integration tests in Quarkus style                   | restructured    | Needs manual rewrite |<br><br>### Test rule<br>Keep test package alignment close to production package alignment.<br><br>---<br><br>## 8. Example package map<br><br>## Source<br>`spring-src/customer-api-spring/src/main/java/com/bank/customer`<br><br>### Source packages<br>- `com.bank.customer.controller`<br>- `com.bank.customer.service`<br>- `com.bank.customer.repository`<br>- `com.bank.customer.config`<br>- `com.bank.customer.dto`<br>- `com.bank.customer.entity`<br>- `com.bank.customer.exception`<br><br>## Target<br>`quarkus-out/customer-api-quarkus/src/main/java/com/bank/customer/quarkus`<br><br>### Target packages<br>- `com.bank.customer.quarkus.api`<br>- `com.bank.customer.quarkus.service`<br>- `com.bank.customer.quarkus.repository`<br>- `com.bank.customer.quarkus.config`<br>- `com.bank.customer.quarkus.dto`<br>- `com.bank.customer.quarkus.entity`<br>- `com.bank.customer.quarkus.exception`<br><br>---<br><br>## 9. File mapping worksheet template<br><br>Use this per migrated file:<br><br>| Source file                                                                                         | Target file                                                                                             | Mapping type              | Reason                           | Notes                  |<br>|-----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|---------------------------|----------------------------------|------------------------|<br>| `spring-src/customer-api-spring/src/main/java/com/bank/customer/controller/CustomerController.java` | `quarkus-out/customer-api-quarkus/src/main/java/com/bank/customer/quarkus/api/CustomerResource.java`    | updated-package-and-class | Quarkus REST resource convention | preserve route path    |<br>| `spring-src/customer-api-spring/src/main/java/com/bank/customer/service/CustomerService.java`       | `quarkus-out/customer-api-quarkus/src/main/java/com/bank/customer/quarkus/service/CustomerService.java` | updated-package           | preserve service naming          |                        |<br>| `spring-src/customer-api-spring/src/main/java/com/bank/customer/config/CustomerProperties.java`     | `quarkus-out/customer-api-quarkus/src/main/java/com/bank/customer/quarkus/config/CustomerConfig.java`   | renamed-class             | migrated to config mapping style | review property prefix |<br><br>---<br><br>## 10. Restructure triggers<br><br>Only restructure packages when one of these is true:<br>- Spring MVC controller package should become a clearer REST API package<br>- source package layout is inconsistent or misleading<br>- source has framework-specific package names that no longer fit target<br>- source mixes unrelated concerns and migration would otherwise become confusing<br><br>Do not restructure just for style.<br><br>---<br><br>## 11. Red flags requiring manual review<br><br>Mark package/file mapping as manual review when:<br>- a file mixes controller + business logic<br>- a config class also performs bean wiring with complex conditions<br>- a repository interface depends on heavy Spring Data conventions<br>- a security package contains Spring-specific configuration adapters<br>- a client package depends on Feign, WebClient, or custom interceptors<br>- a test package depends heavily on Spring test slices or MockMvc<br>- a file name no longer reflects its responsibility after migration<br><br>---<br><br>## 12. Final rules for this workspace<br><br>- Preserve package structure where possible<br>- Rename only when it improves clarity or reflects a real framework change<br>- Prefer `controller` → `api`<br>- Prefer `*Controller` → `*Resource`<br>- Keep source-to-target traceability obvious<br>- Record every non-trivial rename in this file</pre><p><strong>quarkus-rules.md</strong></p><pre># quarkus coding rules<br><br>You are an expert in Java programming, Quarkus framework, Jakarta EE, MicroProfile, GraalVM native builds, Vert.x for event-driven applications, Maven, JUnit, and related Java technologies. follow the rules below to write migrated code.<br><br>## Code Style and Structure<br>- Write clean, efficient, and well-documented Java code using Quarkus best practices.<br>- Follow Jakarta EE and MicroProfile conventions, ensuring clarity in package organization.<br>- Use descriptive method and variable names following camelCase convention.<br>- Structure your application with consistent organization (e.g., resources, services, repositories, entities, configuration).<br><br>## Quarkus Specifics<br>- Leverage Quarkus Dev Mode for faster development cycles.<br>- Use Quarkus annotations (e.g., @ApplicationScoped, @Inject, @ConfigProperty) effectively.<br>- Implement build-time optimizations using Quarkus extensions and best practices.<br>- Configure native builds with GraalVM for optimal performance (e.g., use the quarkus-maven-plugin).<br><br>## Naming Conventions<br>- Use PascalCase for class names (e.g., UserResource, OrderService).<br>- Use camelCase for method and variable names (e.g., findUserById, isOrderValid).<br>- Use ALL_CAPS for constants (e.g., MAX_RETRY_ATTEMPTS, DEFAULT_PAGE_SIZE).<br><br>## Java and Quarkus Usage<br>- Use Java 17 or later features where appropriate (e.g., records, sealed classes).<br>- Utilize Quarkus BOM for dependency management, ensuring consistent versions.<br>- Integrate MicroProfile APIs (e.g., Config, Health, Metrics) for enterprise-grade applications.<br>- Use Vert.x where event-driven or reactive patterns are needed (e.g., messaging, streams).<br><br>## Configuration and Properties<br>- Store configuration in application.properties or application.yaml.<br>- Use @ConfigProperty for type-safe configuration injection.<br>- Rely on Quarkus profiles (e.g., dev, test, prod) for environment-specific configurations.<br><br>## Dependency Injection and IoC<br>- Use CDI annotations (@Inject, @Named, @Singleton, etc.) for clean and testable code.<br>- Prefer constructor injection or method injection over field injection for better testability.<br><br>## Testing<br>- Write tests with JUnit 5 and use @QuarkusTest for integration tests.<br>- Use rest-assured for testing REST endpoints in Quarkus (e.g., @QuarkusTestResource).<br>- Implement in-memory databases or test-containers for integration testing.<br><br>## Performance and Scalability<br>- Optimize for native image creation using the quarkus.native.* properties.<br>- Use @CacheResult, @CacheInvalidate (MicroProfile or Quarkus caching extensions) for caching.<br>- Implement reactive patterns with Vert.x or Mutiny for non-blocking I/O.<br>- Employ database indexing and query optimization for performance gains.<br><br>## Security<br>- Use Quarkus Security for authentication and authorization (e.g., quarkus-oidc, quarkus-smallrye-jwt).<br>- Integrate MicroProfile JWT for token-based security if applicable.<br>- Handle CORS configuration and other security headers via Quarkus extensions.<br><br>## Logging and Monitoring<br>- Use the Quarkus logging subsystem (e.g., quarkus-logging-json) with SLF4J or JUL bridging.<br>- Implement MicroProfile Health, Metrics, and OpenTracing for monitoring and diagnostics.<br>- Use proper log levels (ERROR, WARN, INFO, DEBUG) and structured logging where possible.<br><br>## API Documentation<br>- Use Quarkus OpenAPI extension (quarkus-smallrye-openapi) for API documentation.<br>- Provide detailed OpenAPI annotations for resources, operations, and schemas.<br><br>## Data Access and ORM<br>- Use Quarkus Hibernate ORM with Panache for simpler JPA entity and repository patterns.<br>- Implement proper entity relationships and cascading (OneToMany, ManyToOne, etc.).<br>- Use schema migration tools such as Flyway or Liquibase if needed.<br><br>## Build and Deployment<br>- Use Maven or Gradle with Quarkus plugins for building and packaging.<br>- Configure multi-stage Docker builds for optimized container images.<br>- Employ proper profiles and environment variables for different deployment targets (dev, test, prod).<br>- Optimize for GraalVM native image creation to reduce memory footprint and startup time.<br><br>## Follow best practices for:<br>- RESTful API design (proper use of HTTP methods and status codes).<br>- Microservices architecture, leveraging Quarkus for fast startup and minimal memory usage.<br>- Asynchronous and reactive processing using Vert.x or Mutiny for efficient resource usage.<br><br>## Adhere to SOLID principles to ensure high cohesion and low coupling in your Quarkus applications.</pre><h3>What happens next</h3><p>Once the workflow is triggered it runs through the steps, follows instructions and rules, iterates through and generates the outputs. That is, at the end of all iterations it creates the migrated code, error-free and tested successfully. During the process it prompts the user to accept the changes.</p><p>At last human code review and deep functional understanding is required. While generated code can save time, knowing the code intimately is a necessity for avoiding cognitive-debt build-up over time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e250b6312052" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Are Reasoning Models any good?]]></title>
            <link>https://mlbits.medium.com/are-reasoning-models-any-good-3b29a580c10c?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b29a580c10c</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[lrm]]></category>
            <category><![CDATA[reasoning-model]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Wed, 31 Dec 2025 03:47:11 GMT</pubDate>
            <atom:updated>2025-12-31T03:47:11.793Z</atom:updated>
            <content:encoded><![CDATA[<p>LRMs caught the better of LLM wave. How does it work? Are those any different from the LLMs? Unlike standard Large Language Models (LLMs) that focus on predicting the next statistically likely word immediately, LRMs somehow give the imression of “thinking” before they spurt out responses. They prioritise <strong>Test-Time Compute</strong>, meaning they spendn somewhat more computational power and time during the inference phase.</p><p><strong>Chain of Thought:</strong></p><p>LRMs lays down a plan, consider options, and perform intermediate steps (a “chain of thought”) before generating a final answer. This process effectively forces the model to perform multiple forward passes through its neural network, simulating a reasoning process similar to a human “showing their work” on a math problem.</p><h3>How Large Reasoning Models Are Created</h3><p>Creating an LRM involves a multi-stage process that builds upon the foundation of a standard LLM.</p><p><strong>Step 1: Massive Pre-training (The Foundation)</strong></p><p>LRMs start as standard LLMs. They undergo massive pre-training on billions of web pages, books, and code to acquire general language skills and world knowledge.</p><p><strong>Step 2: Supervised Fine-Tuning (SFT) for Reasoning</strong></p><p>The model is then fine-tuned on curated datasets containing logic puzzles, complex math, and coding tasks. Crucially, these datasets include the full chain of thought answer key, teaching the model to imitate the step-by-step reasoning process rather than just memoizing the final answer. This stage teaches the model format and structure of reasoning.</p><p><strong>Step 3: Reinforcement Learning (The “Thinking” Engine)</strong></p><p>This is the critical differentiator. The model is then placed in an environment where it attempts to solve problems with verifiable answers (like math or code).</p><ul><li><strong>Verifiable Rewards:</strong> The model receives a reward (thumbs up) or penalty (thumbs down) based on whether the final answer is correct. It learns to adjust its internal parameters to maximize these rewards.</li><li><strong>Process Reward Models:</strong> In more advanced setups, “Process Reward Models” judge each individual step of the logic chain as “good” or “bad,” not just the final result. This improves logical coherence throughout the entire chain.</li><li><strong>Emergent Behavior:</strong> Interestingly, as models undergo this reinforcement learning, their reasoning chains naturally become longer, correlating with improved performance.</li></ul><p><strong>Step 4: Distillation (Optional Efficiency)</strong></p><p>To create smaller, more efficient LRMs, developers may use a large “teacher” model to generate high-quality reasoning traces. These traces are then used to train smaller “student” models, effectively transferring the reasoning capability without the massive computational overhead of the larger model.</p><h3>Are LRMs really reasoning?</h3><p>LRMs are still just Transformers — which means, at their core, they are still just predicting one token (word/part of a word) at a time. There is no separate “reasoning module” or a different physical brain that turns on. The “start” of reasoning is purely a statistical trigger, purely based on what and how the model is trained on. In case of LRMs the model has been fine-tuned (Supervised Fine-Tuning) to output a special “start of thought” token immediately after a problem is posed. Let’s call it &lt;think&gt;.</p><h4>Thinking</h4><p><strong>The Trigger:</strong> When the user hits enter, the model processes your question. Because of its specific training, the mathematically most probable next token to generate is not “The answer is…” but rather &lt;think&gt;.</p><p>Once that &lt;think&gt; token is generated, it acts as a signal to the attention mechanism. The model effectively enters a “reasoning mode” where the probability distribution for the next tokens shifts entirely toward generating intermediate steps rather than final answers.</p><p><strong>The “Hidden” Generation (Test-Time Compute): </strong>The “thinking” time is actually just the model generating text that is not part of the response you see.</p><ul><li>It is not “pausing” to think. It is furiously writing a monologue to itself.</li><li>It generates a chain of thoughts: <em>“Okay, the user wants X. First I need to check Y. Let’s calculate Z…”</em></li></ul><p><strong>The “Stop” Token:</strong> Eventually, the model reaches a conclusion. It has been trained that once the logic is complete, it should generate a “end of thought” token (e.g., &lt;/think&gt;).</p><p>Eventually this thinking also feeds into the attention mechanism of the model and generates the actual answer in context of the “thinking”, following with the answering tokens.</p><p>Hence still the biggest challenge for LRMs are problems that are truly novel in its type i.e., never seen by it in its training data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b29a580c10c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is NVIDIA’s GPU supremacy at risk? — Part 4]]></title>
            <link>https://mlbits.medium.com/is-nvidias-gpu-supremacy-at-risk-part-4-ef8d90ef13e4?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef8d90ef13e4</guid>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[ai-inferencing]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[nvidia]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Sun, 21 Sep 2025 06:47:30 GMT</pubDate>
            <atom:updated>2025-09-21T06:48:21.107Z</atom:updated>
            <content:encoded><![CDATA[<h3>Is NVIDIA’s GPU supremacy at risk? — Part 4</h3><h3>LLM Inferencing Workload for GPUs</h3><p>LLM inferencing uses quite a different kind of architecture compared to the other kind of neural networks. LLMs use a mechanism called self-attention mechanism that requires the entire context, up to the last generated token to be available in GPU memory. This makes this a GPU memory bound workload, especially for requests with long context window. When we compare self-attention mechanism in transformation architecture with traditional RNNs or CNNs this difference becomes clearer.</p><h3>Self-attention Mechanism in Transformation Architecture compared to RNNs or CNNs</h3><p><strong>Convolutional Network</strong></p><ol><li>Input to a Convolutional Neural Network (CNN) is processed as a whole as a multi-dimensional array or tensor.</li><li>Feed-forward network, that is, the output is not fed back into the network</li><li>Size of the input and out are fixed</li><li>Used for matrix type data such as images, structured data etc.</li></ol><p><strong>Recurrent Network</strong></p><ol><li>RNNs process inputs sequentially, one token is sent at a time through the network</li><li>The result is fed back into the network (recurrent)</li><li>The size of input and output are not fixed</li><li>Used for sequential data such as text, speech, time-series data etc.</li></ol><p>An RNN typically consists of:</p><p>1) Input layer</p><p>2) Hidden recurrent layers (e.g., LSTM, GRU)</p><p>3) Output layer</p><p>Hidden layers maintain state across time steps to capture temporal dependencies</p><p>Prior to self-attention mechanism, RNNs (Recurrent Neural Network) were used for NLP.</p><p>But, Recurrent Neural Networks have short reference window because:</p><ol><li>It does not cache all previous tokens. It rather attempts to retain the effects of all previous tokens in a very compressed way in the hidden layer weights. This fades quickly as more tokens are passed.</li><li>During training, gradients can vanish or explode as they propagate through steps many times. This makes it hard for RNNs to learn long-range dependencies.</li></ol><p><strong>Self-Attention Mechanism of Transformation Architecture</strong></p><p>One big difference in self-attention mechanism is that all tokens are passed together through the model to generate the next token. Here is a summary:</p><ol><li>Input tokens are processed together using self-attention mechanism and are cached (pre-fill). Then one token is produced at a time as output. And even the output tokens are also cached.</li><li>Next token is then generated using all previous tokens. Each token attends to all other tokens in the sequence. So, in effect, all tokens are processed simultaneously, not sequentially.</li><li>Positional encoding is added to retain order</li><li>Used for sequential data like text, speech, and also adaptable to other modalities</li></ol><p>Transformer block consists of:</p><ol><li>Multi-head self-attention layer</li><li>Add &amp; Norm (Layer Normalization)</li><li>Feed-forward network</li><li>Add &amp; Norm (Layer Normalization)</li></ol><p>Stacked layers allow modelling of complex dependencies.</p><h3>LLM Inferencing Mechanism through the GPU</h3><p>In the context of the GPU the overall process translates to the following steps</p><ol><li>Model Weights Loaded on GPU Memory</li></ol><p><em>a) Pre-trained model weights (parameters of the Transformer layers) are loaded into GPU memory.</em></p><p><em>b) These weights include matrices for query, key, value projections, feed-forward layers, and positional encodings.</em></p><p><em>c) This enables fast matrix operations during inference.</em></p><p>2. Tokenization</p><p>a) The input prompt is converted into tokens using a tokenizer (e.g., Byte-Pair Encoding).</p><p>b) Tokens are mapped to embedding vectors using a lookup table.</p><p>c) This step happens before data enters the GPU.</p><p>3. Prefill Phase</p><p>a) The token embeddings are passed into the Transformer layers.</p><p>b) Self-attention computes relationships between tokens using: Query (Q), Key (K), Value (V) projections.</p><p>c) Attention scores are calculated and used to weight the values.</p><p>d) These processed embeddings are cached on the GPU:</p><p>e) Caching stores the key and value tensors for each token. This avoids re-computation during autoregressive decoding.</p><p>f) The cache grows with each generated token.</p><p>4. Decode/Generation Phase</p><p>a) One token is generated at a time using the cached context.</p><p>b) The new token is added to the cache and used to compute the next token.</p><p>c) This continues until an end-of-sequence token is produced or a length limit is reached.</p><p>5. De-tokenization</p><p>a) The generated tokens are converted back into human-readable text. This step happens after data leaves the GPU.</p><h3>GPU memory optimization for self-attention Mechanism</h3><h3>NVIDIA GPUs offer several competitive advantages for LLM inferencing workloads, especially around memory optimization and compute efficiency for self-attention mechanisms. Here’s a breakdown of how NVIDIA supports and enhance</h3><h3>KV Caching</h3><ul><li>TensorRT-LLM and NVIDIA FasterTransformer support efficient KV caching by storing K/V tensors in GPU memory across autoregressive steps.</li><li>Memory-efficient layouts: NVIDIA uses optimized memory layouts (e.g., contiguous memory blocks) to reduce fragmentation and improve cache access speed.</li><li>Multi-stream support: KV caches are managed per stream/session, enabling concurrent inference across multiple users with minimal overhead.</li></ul><p>Impact: Reduces re-computation, lowers latency, and scales well with longer context windows.</p><p>Compare this to AMD for example, it is software dependent, not a GPU level optimization. KV caching is framework-dependent, not hardware-specific. PyTorch and Hugging Face Transformers support KV caching, and this works on AMD GPUs via ROCm.</p><h3>PagedAttention</h3><p>PagedAttention is a memory management strategy designed for efficient KV cache handling. It divides the KV cache into fixed-size memory pages, allowing dynamic allocation and reuse.</p><ul><li>TensorRT-LLM implements PagedAttention to manage KV cache memory using a paging system similar to virtual memory.</li><li>Dynamic memory allocation: Pages are allocated and reused efficiently, reducing memory fragmentation.</li><li>Scalable multi-user inference: Especially beneficial in serving environments like Triton Inference Server, where multiple sessions run concurrently.</li></ul><p>Impact: Predictable memory usage, better scalability, and reduced memory waste.</p><p>Considering AMD as an alternate option, PagedAttention is not natively supported on AMD GPUs.</p><h3>FlashAttention</h3><ul><li>NVIDIA GPUs (especially Hopper and Ampere architectures) support FlashAttention v2, which is deeply optimized for CUDA.</li><li>Register-level tiling: Keeps intermediate results in registers, avoiding slow global memory access.</li><li>Fused operations: Softmax and matrix multiplications are fused into a single kernel.</li><li>TensorRT-LLM integration: FlashAttention is integrated into TensorRT-LLM for both training and inference.</li></ul><h3>Kernel Fusion</h3><p>Kernel fusion combines multiple GPU operations (e.g., matrix multiplication, bias addition, activation functions) into a single GPU kernel. This reduces:</p><ul><li>Kernel launch overhead</li><li>Memory bandwidth usage</li><li>Latency</li></ul><p>In the context of self-attention, kernel fusion is used to accelerate the QKV projections, attention score computation, and feed-forward layers. It’s a key optimization for real-time inference and deployment.</p><p><strong>With all these optimizations, NVIDIA GPUs can better perform LLM inferencing worklowads especially when</strong></p><ol><li><strong>A large context window is required, with a large LLM</strong></li><li><strong>Inferencing speed or token throughput is a critical requirement</strong></li><li><strong>Parallel sessions</strong></li></ol><p><strong>However, with respect to inferencing often less through-put, lack of parallel sessions or a shorter context window is less of a showstopper.</strong></p><h4>Sources</h4><ol><li><a href="https://youtu.be/9tvJ_GYJA-o?si=iBbwGbOVmvzoaGk3">Mastering LLM Inference Optimization From Theory to Cost Effective Deployment: Mark Moyou</a></li><li><a href="https://rocm.blogs.amd.com/artificial-intelligence/llm-inference-optimize/README.html">https://rocm.blogs.amd.com/artificial-intelligence/llm-inference-optimize/README.html</a></li><li><a href="https://infohub.delltechnologies.com/de-de/p/benchmarking-nvidia-gpu-throughput-for-llms-and-understanding-gpu-configuration-choices-in-the-ai-space/">https://infohub.delltechnologies.com/de-de/p/benchmarking-nvidia-gpu-throughput-for-llms-and-understanding-gpu-configuration-choices-in-the-ai-space/</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef8d90ef13e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is NVIDIA’s GPU supremacy at risk? — Part 3]]></title>
            <link>https://mlbits.medium.com/is-nvidias-gpu-supremacy-at-risk-part-3-58bb1a665e76?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/58bb1a665e76</guid>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[training]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Sun, 24 Aug 2025 02:08:29 GMT</pubDate>
            <atom:updated>2025-08-24T02:08:29.750Z</atom:updated>
            <content:encoded><![CDATA[<h3>Is NVIDIA’s GPU supremacy at risk? — Part 3</h3><p>In this installment, I will explore the importance of high GPU memory bandwidth for LLM training workloads and how NVIDIA is handling it.</p><h3>GPU Memory Bandwidth is crtical for Training Large Language Models</h3><p>LLM Training Process involves updating and accessing a number of tensor-type data (vectors) that require really high memory bandwidth for frequent read/write operations. To get a sense of these operations here is an high-level description of each and why they need memory in the GPU:</p><p>• Parameters <br>• Activations<br>• Gradients<br>• Optimizer states</p><h4>1. Model Parameters (Weights)</h4><p>Each parameter (weight) in the model must be stored and updated during training. For FP16 (2 bytes) precision, storing 1 trillion parameters requires:</p><p>1 trillion×2 bytes=2 TB1 trillion×2 bytes=2 TB</p><p>For example:<br>• GPT-3 has 175 billion parameters → requires approximately 350 GB in FP16.<br>• PaLM (Google, 2022) has 540 billion parameters → about 1.08 TB in FP16.<br>• GPT-4 (estimated) may exceed 1 trillion parameters → about 2 TB in FP16</p><h4>2. Activations</h4><p>In a neural network, activations refer to the outputs of neurons after applying an activation function (like ReLU or GELU) to the weighted sum of inputs. These activations introduce non-linearity, enabling the model to learn complex patterns beyond simple linear relationships. During the forward pass, each layer computes its activations and stores them in GPU memory. These stored activations are essential for the backward pass (backpropagation), where the model calculates gradients with respect to weights. Without storing these intermediate outputs, the model wouldn’t be able to compute how much each weight contributed to the final error.</p><p>For each layer, the size of its output activations can be calculated by multiplying the dimensions of the output tensor by the batch size and the bytes per element for the chosen data type.</p><p>Activation Memory ≈ Batch Size × Hidden Size × Bytes per Element</p><p>Where:<br> • Batch Size: Number of samples processed in parallel. Larger batches increase memory usage.<br> • Hidden Size: Number of neurons or features in a layer.<br> • Bytes per Element: Depends on data type (e.g., FP32 = 4 bytes, FP16/BF16 = 2 bytes).<br> • Number of Layers: Total memory is the sum across all layers.</p><p>Then the total activation memory is the sum of the estimated memory for activations from all layers. Activation memory can exceed 10–20 GB for large models with long sequences and large batch sizes, especially when storing attention maps and intermediate tensors.</p><h4>3. Gradient</h4><p>Gradients are computed during the backward pass of training using the stored activations and the loss function. These gradients represent how much each parameter should be adjusted to minimize the loss.</p><p>• For each parameter in the model, a corresponding gradient must be computed and stored.<br> • The memory required for gradients is roughly equal to the memory required for the model parameters.<br> • For FP16 precision, storing gradients for 1 trillion parameters also requires 2 TB.</p><p>During backpropagation, gradients are computed layer by layer and must be written to memory quickly. High memory bandwidth ensures that these frequent read/write operations do not become a bottleneck.</p><h4>4. Optimizer State</h4><p>Neural networks learn by minimizing a loss function, which quantifies the error between the network’s predictions and the actual target values. Optimizers use the gradients (derivatives) of the loss function to determine how to adjust the network’s parameters. The optimizer iteratively updates the weights and biases based on these gradients, moving the network’s parameters in a direction that reduces the loss. Hence, optimizers like Adam or LAMB maintain additional states for each parameter to improve convergence. These typically include:</p><p>• First moment (mean of gradients)<br> • Second moment (variance of gradients)</p><p>Each of these states requires additional memory per parameter. For example:</p><p>• Adam requires 2× the memory of the parameters (first and second moments).<br> • For 1 trillion parameters in FP16, optimizer states may require 4 TB (2 TB for each moment).</p><h3>Why memory bandwidth matters during LLM training:</h3><p>Training large language models (LLMs) involves massive data movement between GPU compute cores and memory. Every training step requires reading and writing several types of data: model parameters, activations, gradients, and optimizer states. These operations are not only compute-intensive but also memory bandwidth-bound — meaning the speed at which data can be moved in and out of GPU memory becomes a major bottleneck.</p><p>As a result, the demand on memory bandwidth can exceed several terabytes per second. GPUs like NVIDIA A100 or H100 are designed with high-bandwidth memory (HBM2/HBM3) to support this, but even then, bandwidth remains a limiting factor.</p><p>Why Multi-GPU Training Needs Even Higher Bandwidth<br>In large-scale LLM training, a single GPU cannot hold the entire model or batch. Training is distributed across multiple GPUs, often using data parallelism, tensor parallelism, or pipeline parallelism. This introduces additional memory bandwidth and communication challenges:</p><p>• Model Sharding: Parameters are split across GPUs, requiring cross-GPU communication during forward and backward passes.<br> • Gradient Synchronization: Gradients must be aggregated across GPUs (e.g., via all-reduce operations), which involves high-throughput memory and interconnect usage.<br> • Activation Checkpointing: To save memory, some activations are recomputed during backpropagation, increasing memory traffic further.</p><p>In this context, high memory bandwidth is essential not just within each GPU, but also across GPUs via high-speed interconnects like NVLink, NVSwitch, or InfiniBand. Without sufficient bandwidth, GPUs spend more time waiting for data than performing computation, leading to underutilization and slower training.</p><p>There are couple of key pieces of technology that helps overcome this barrier.</p><h3>HBM (High-Bandwidth Memory)</h3><p>HBM is on-package memory that provides GPU cores access to high-speed memory.</p><p>• Bandwidth: HBM3 and HBM3E can deliver up to 1.2 TB/s per stack, which is crucial for keeping GPU cores saturated with data.<br> • Power Efficiency: Uses less energy per bit than GDDR or DDR memory, which is vital for thermal and energy constraints in dense AI clusters.<br> • Form Factor: Stacked vertically using TSV (Through-Silicon Vias), allowing it to sit close to the GPU die on an interposer — minimizing latency.</p><p>The market dynamics for HBMs are dominated by a handful of players:</p><p>• SK Hynix: Currently the leading supplier, especially for HBM3 and HBM3E, and reportedly the exclusive supplier for NVIDIA’s H100 and H200 GPUs until recently.<br> • Samsung: Gaining traction with HBM3E and working on HBM4. Also investing in advanced packaging to compete with SK Hynix.<br> • Micron: A smaller player for GPU memory, but innovating with low-power HBM3 and UCIe-compatible packaging.</p><p>These companies do not supply to Chinese GPU manufacturers like Huawei due to trade restrictions imposed by the US.</p><h3>CPO (Co-packaged Optics)</h3><p>CPO is co-package interconnect that enables high-bandwidth, low-latency optical links amongst GPUs across nodes, allowing fast model parallelism or data parallelism. Unlike a conventional pluggable optical transceiver that slots into a front panel, a CPO optical module (often called an optical engine) is integrated directly onto the same substrate or interposer as the switching/routing ASIC, hence it is called co-packaged. This helps data move faster and saves power. Driving high-speed electrical signals (224G PAM4 and beyond) across inches of PCB to reach front-panel pluggables consumes excessive power (~10–15 pJ/bit or more). CPO optical modules reduce this distance to millimeters, potentially cutting I/O power by &gt;50% per bit.</p><p>NVIDIA’s current CPO implementations are focused on networking switches, specifically the Quantum-X and Spectrum-X platforms. During a keynote talk at “GTC 2025”, Nvidia’s CEO Jensen Huang introduced new silicon photonics network switch technologies, called “Spectrum-X” and “Quantum-X” which are Ethernet and InfiniBand switches respectively. They are designed to scale AI “factories” to millions of GPUs connected with 1.6 Tb/s port switches, using CPO to provide short-range connections as a way to improve overall electrical efficiency</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58bb1a665e76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is NVIDIA’s GPU supremacy at risk? — Part 2]]></title>
            <link>https://mlbits.medium.com/is-nvidias-gpu-supremacy-at-risk-part-2-72a139badc83?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/72a139badc83</guid>
            <category><![CDATA[cuda]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[rapids-ai]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Thu, 31 Jul 2025 03:59:22 GMT</pubDate>
            <atom:updated>2025-07-31T03:59:22.912Z</atom:updated>
            <content:encoded><![CDATA[<h3>Is NVIDIA’s GPU supremacy at risk? — Part 2</h3><h3>How ML and Deep Learning Workload Leverage GPUs?</h3><p>To understand how NVIDIA GPU accelerators help modern deep-learning workloads, it is better to logically break them down in the following three layers of software that is required in addition to the physical GPUs:</p><ol><li>Deep Learning Frameworks</li><li>CUDA Toolkit</li><li>NVIDIA Drivers</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/436/1*jcumcL76_AD9ECRLk2UkIQ.png" /><figcaption>NVIDIA’s Deep-Learning Stack</figcaption></figure><p>Image created with help of the source image here: <a href="https://docs.nvidia.com/datacenter/tesla/drivers/_images/cuda-x.png">https://docs.nvidia.com/datacenter/tesla/drivers/_images/cuda-x.png</a></p><p>1. Deep learning frameworks like TensorFlow, PyTorch, MXNet, and JAX are designed to abstract the complexity of building and training neural networks. These frameworks:</p><ul><li>CUDA compatible version of these frameworks detect and utilize available GPUs.</li><li>Support distributed training across multiple GPUs leveraging NVLink and NVSwitch technologies.</li><li>Provide APIs for model definition, training loops, and deployment, while offloading heavy computation to the GPU.</li><li>These frameworks rely on the CUDA ecosystem to interface with the GPU hardware efficiently. For example, <br>&gt;&gt; In case of installing PyTorch for use with NVIDIA GPUs, a specific version of PyTorch compiled with CUDA support is required. This installation includes necessary bridging library component such, CUDA Toolkit, cuDNN, NCCL (NVIDIA Collective Communications Library).<br>&gt;&gt; TensorFlow offers a specific version (e.g., tensorflow-gpu) that is built with support for GPU acceleration. This package includes the necessary bindings and configurations to interact with CUDA and cuDNN, allowing TensorFlow to automatically detect and utilize available NVIDIA GPUs for computations when the prerequisites are met.</li></ul><p>These frameworks leverage various NVIDIA Deep-learning Libraries to optimize workloads on NVIDIA GPU. For example, cuDNN is Deep Neural Network library optimized for training and inference.</p><p>2. The CUDA Toolkit is NVIDIA’s platform for GPU computing. It provides the foundational software stack that enables deep learning frameworks and custom ML applications to run on NVIDIA GPUs. Key components include:</p><ul><li>CUDA Runtime and Driver APIs: Manage GPU memory, launch kernels, and handle device contexts.</li><li>NCCL: NVIDIA Collective Communication library for multi-GPU and multi-node training.</li><li>Thrust, cuBLAS, cuFFT: Libraries for linear algebra, sorting, and signal processing.</li><li>CUDA Compiler (NVCC): Compiles GPU kernels written in CUDA C/C++. The toolkit allows developers to write custom GPU-accelerated code or leverage optimized libraries used by deep learning frameworks.</li></ul><p>3. Underneath these libraries, OS specific NVIDIA drivers are essential for enabling GPU functionality at the OS level. They include:</p><ul><li>Kernel Driver: Interfaces directly with the GPU hardware, managing memory, scheduling, and device control.</li><li>CUDA Driver (libcuda.so): Provides low-level access for CUDA applications and libraries.</li><li>Display Driver: Manages graphics output (if applicable), but is separate from compute functionality.</li><li>These drivers ensure that the GPU is recognized by the system, properly initialized, and accessible to CUDA applications and deep learning frameworks. Without them, the CUDA Toolkit and frameworks cannot communicate with the GPU.</li></ul><h3>Deep-Learning Libraries</h3><h4>cuDNN</h4><p>cuDNN provides optimized kernels that leverage Tensor Cores on NVIDIA GPUs to significantly speed up computation-heavy operations like matrix multiplication and convolution. It includes highly tuned implementations of operations like pooling, activation functions (ReLU, sigmoid, etc.).</p><p>cuDNNprovides highly optimized implementations of standard deep learning operations, such as:</p><ul><li>Convolution (2D/3D)</li><li>Pooling (max, average)</li><li>Activation functions (ReLU, Sigmoid, Tanh)</li><li>Softmax, normalization,</li><li>Normalization (BatchNorm, LayerNorm)</li><li>RNNs and LSTMs</li><li>Tensor transformations</li></ul><p>NVIDIA cuDNN (CUDA Deep Neural Network library) can be used with C, C++, Python. Deep learning frameworks like PyTorch leverage cuDNN as a highly optimized backend library to accelerate computationally intensive operations when running on NVIDIA GPUs.</p><h4>RAPIDS</h4><p>RAPIDS is an open-source suite of GPU-accelerated libraries developed by NVIDIA that enables pandas like dataframe-oriented data science and analytics workloads to run entirely on the GPU. It leverages CUDA and other NVIDIA technologies to dramatically speed up data preparation, machine learning, and graph analytics tasks.</p><p>RAPIDS provides optimized GPU implementations of common data science operations such as:</p><ul><li>DataFrame manipulation (similar to pandas)</li><li>SQL-like queries</li><li>Data cleaning and transformation</li><li>Feature engineering</li><li>Machine learning model training and inference</li><li>Graph analytics and visualization</li></ul><p>Key RAPIDS libraries include:</p><ul><li>cuDF: GPU DataFrame library for tabular data manipulation</li><li>cuML: GPU-accelerated machine learning algorithms (e.g., linear regression, k-means, random forests)</li><li>cuGraph: GPU-based graph analytics</li><li>cuSpatial: Geospatial data processing</li><li>Dask + RAPIDS: Scalable multi-GPU and distributed computing<br>RAPIDS is built on top of CUDA, and it interacts with the CUDA runtime and driver to execute operations directly on NVIDIA GPUs. It can be used with Python, C++, and integrates seamlessly with popular data science tools like scikit-learn, NumPy, and Apache Arrow.</li></ul><p>By keeping data on the GPU throughout the pipeline — from preprocessing to model training — RAPIDS eliminates costly CPU-GPU data transfers and enables real-time analytics and interactive data science at scale.</p><h4>DALI</h4><p>DALI provides optimized implementations of common image pre-processing operations for deep-learning :</p><ul><li>Image decoding and resizing</li><li>Cropping, flipping, rotation</li><li>Normalization and color space conversion</li><li>Data augmentation (random noise, contrast, brightness)</li><li>Sequence and video processing</li><li>Support for mixed CPU-GPU pipelines</li></ul><p>DALI is built to run pre-processing operations directly on NVIDIA GPUs, leveraging CUDA to accelerate tasks that are traditionally handled by the CPU. This enables end-to-end GPU utilization, from data ingestion to model training, minimizing idle time and maximizing throughput.</p><p>It integrates seamlessly with popular deep learning frameworks like TensorFlow, PyTorch, and MXNet, and can be used with Python or C++. DALI supports both eager execution and graph-based pipelines, making it flexible for a wide range of training workflows.</p><p>By offloading data pre-processing to the GPU, DALI helps eliminate the data loading bottleneck, especially in large-scale training scenarios involving high-resolution images or video data.</p><h4>CUTLASS</h4><p>CUTLASS (CUDA Templates for Linear Algebra Subroutines) is an open-source CUDA C++ template library developed by NVIDIA that provides highly optimized building blocks for linear algebra operations on NVIDIA GPUs. It is designed to help developers implement custom, high-performance matrix multiplication and related operations, which are foundational to deep learning and scientific computing.</p><p>CUTLASS provides GPU-accelerated templates for:</p><ul><li>General Matrix Multiplication (GEMM)</li><li>Batched GEMM</li><li>Tensor contractions</li><li>Sparse and mixed-precision operations</li><li>Epilogue operations (e.g., activation, scaling, bias addition)</li></ul><p>CUTLASS is built to leverage Tensor Cores on modern NVIDIA GPUs, enabling extremely fast and efficient matrix computations in FP16, BF16, INT8, and TF32 formats</p><h3>CUDA Toolkit</h3><h4>CUDA Runtime</h4><p>Example of how these components interact:</p><ul><li>Application calls cudaMalloc() → CUDA Runtime</li><li>CUDA Runtime calls cuMemAlloc() → CUDA Driver</li><li>CUDA Driver communicates with kernel driver → GPU hardware</li></ul><h3>NVIDIA Drivers</h3><h4>Kernel Driver</h4><p>A software component that acts as a bridge between the NVIDIA graphics card and the operating system’s kernel providing low level utility for the OS such as</p><ul><li>Initialize the GPU during boot and register it as a system device</li><li>Manage GPU interrupts</li><li>Handle memory mapping and device I/O</li><li>Manage power and thermal states</li><li>The kernel driver enforces access control between processes.</li></ul><h4>UVM (Unified Virtual Memory)</h4><p>UVM stands for Unified Virtual Memory, a feature in NVIDIA’s CUDA architecture that allows seamless memory sharing between the CPU and GPU. It simplifies programming by enabling a single memory space accessible by both host (CPU) and device (GPU), removing the need for explicit memory copies. It enables CUDA applications to have simplified way of accessing memory through a single virtual address space and CUDA runtime automatically moves data between CPU and GPU memory as needed.</p><h4>NVLink</h4><p>NVLink is NVIDIA’s high-speed, direct GPU-to-GPU and GPU-to-CPU interconnect technology, comprising of hardware &amp; software, designed to overcome the limitations of traditional PCIe (Peripheral Component Interconnect Express) in high-performance computing (HPC), AI, and data-intensive workloads. NVLink lanes are routed through the GPU PCB and system motherboard.</p><ul><li>NVLink offers significantly higher bandwidth than PCIe. NVLink 2.0 provides up to 25 GB/s per link, as opposed to 16 GB/s in Gen4 PCIe. Multiple NVlinks can be aggregated for even higher throughput.</li><li>For multi-GPU workloads this means GPU memory pooling, allowing GPUs to access each other’s memory directly. Deep-learning training is a good example.</li><li>For large-scale systems (like NVIDIA DGX), NVSwitch extends NVLink by acting as a fabric switch, enabling all-to-all GPU connectivity with uniform bandwidth and latency.</li></ul><p>For reference, each Blackwell GPU now has up to 1.8 TB/s of bidirectional NVLink bandwidth to connect with others. This is also a hardware capability.</p><h4>NVSwitch</h4><p>At a large-scale systems level (like NVIDIA DGX), NVSwitch extends NVLink by acting as a fabric switch, enabling all-to-all GPU connectivity with uniform bandwidth and latency.</p><ul><li>It is essentially a high-bandwidth switch chip used in systems like NVIDIA DGX and HGX connecting multiple GPUs in a fully connected mesh topology.</li><li>Each NVSwitch supports multiple NVLink connections per GPU allowing all-to-all GPU communication with uniform bandwidth and latency.</li></ul><p>Like NVLink this also requires software and hardware to work together.</p><h4>CUDA Driver</h4><p>The CUDA(Compute Unified Device Architecture) driver is part of the NVIDIA GPU driver stack that provides low-level access to the GPU hardware for CUDA applications. CUDA driver enables programmers to write</p><ul><li>Low-level API for managing devices, contexts, memory, and kernel execution.</li><li>Detects and initializes CUDA-capable GPUs.</li><li>Manages multiple devices and contexts for CUDA applications</li><li>Manages unified memory (UVM) and allocates/frees device memory</li></ul><p>CUDA APIs are accessed using libcuda.so / nvcuda.dll distributions that internally uses CUDA driver.</p><h4>NCR (NVIDIA Container Runtime for Linux)</h4><p>NCR runs on each GPU enabled nodes and enables containers to access NVIDIA GPUs by injecting drivers, CUDA libraries, and device files in the container.</p><ul><li>NCR detects the container’s GPU requirements.</li><li>NCR mounts required files in the container: <br>&gt;&gt; GPU device files (/dev/nvidia0, /dev/nvidiactl, etc.)<br>&gt;&gt; Host CUDA driver libraries (libcuda.so)</li><li>CUDA application inside the container uses the CUDA runtime (libcudart.so).</li><li>CUDA runtime calls into the host CUDA driver via NCR.</li><li>CUDA driver communicates with the NVIDIA kernel driver to execute GPU operations.</li></ul><h4>NVML</h4><p>NVML stands for NVIDIA Management Library, and it plays a crucial role in monitoring and managing NVIDIA GPU devices. It provides a C-based API that allows system administrators, developers, and monitoring tools to query and control various aspects of GPU operation.</p><p>NVML enables access to:</p><ul><li>GPU temperature, power usage, and fan speed</li><li>Memory usage and utilization</li><li>GPU process information</li><li>ECC error counts</li><li>MIG (Multi-Instance GPU) configuration</li><li>NVLink status and bandwidth</li><li>Driver and firmware versions</li></ul><p>In summary, NVML communicates with the kernel driver to access low-level hardware metrics.</p><h4>SMI</h4><p>SMI, specifically nvidia-smi (NVIDIA System Management Interface), is a command-line utility and part of the NVIDIA Management Library (NVML). It provides real-time monitoring and management of NVIDIA GPU devices on a system.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72a139badc83" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is NVIDIA’s GPU supremacy at risk? — Part 1]]></title>
            <link>https://mlbits.medium.com/is-nvidias-gpu-supremacy-at-risk-ef8d74a4a227?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef8d74a4a227</guid>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Thu, 31 Jul 2025 01:43:49 GMT</pubDate>
            <atom:updated>2025-07-31T01:45:13.398Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>As AI models grow in complexity and scale, the underlying hardware and software infrastructure must evolve to support efficient training and inference. This article explores the architectural landscape of GPUs, the role of tensor cores, the differences between GPUs and TPUs, and how large language models (LLMs) are deployed across hardware platforms like vLLM. <br>The objective is to track alternate options (like Huawei GPUs or CPUs or TPUs on the cloud, in place of NVIDIA GPUs) and how they challenge NVIDIA’s supremacy. This is a multi-part series starting with explaning the basics of the hardware and software architecture of NVIDIA GPU ecosystem.</p><h3>GPU Architecture Overview</h3><h4>Chiplet-Based Design</h4><p>Chiplet-based GPU architectures are becoming increasingly common, offering a modular approach to GPU design compared to traditional monolithic designs. In the traditional Monolithic GPU architecture, all GPU components (cores, memory controllers, etc.) are integrated onto a single silicon die. In the Chiplet based approach, it breaks down the GPU into smaller, modular units called chiplets, which are then interconnected. These chiplets can be specialized for different tasks (e.g., compute, memory, I/O) and can be combined in various ways to create different GPU configurations. This design allows heterogenous integration where different type of silicons such as CPU, GPU and other accelerators can be combined. Modern GPUs increasingly use chiplet architectures, allowing manufacturers to modularize components for better scalability, yield, and thermal, power efficiency, and performance. NVIDIA’s Blackwell B200 GPU, Intel’s Gaudi 3 [1] , and AMD’s MI300X all use multi-die designs to optimize compute density and power efficiency.[2] To better understand the backdrop, it is relevant to understand that as Moore’s law reached its limit, with lower transistor performance, the single-thread performance improvements slowed down. Rather than denser wafers. architecture innovations were needed to improve single-thread performance. In the meantime, CPU vendors also started integrating more cores inside the die to double/triple the overall performance of the chip. This is dubbed as a System On a Chip (SOC) era. Instead of packing more cores inside a large die, it became more economical to develop medium-sized CPU cores and connect them inside the package to get higher core density at the package level. These packages with more than one logic die inside are called multi-chip modules (MCMs). This chiplet architecture works only if the interconnects between the chips are fast enough not to slow down the performance of the chips.<br>In parallel, GPU performance was also getting affected by the DRAM performance wall. Around this time (2011), High Bandwidth Memory (HBM) was developed to respond to the increasing demands for bandwidth from the GPUs. Data centre servers with multiple CPUs/GPUs and HBM interfaces benefit from 3D stacking in the vertical direction and advanced 2.5D stacking for interconnectivity between the chiplets and HBM on the silicon interposer/EMIB, like in the schematic shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S2rtsVd_L6ZKK10BoKRPyw.png" /><figcaption>GPU Chiplet Schematic</figcaption></figure><p>Source: <a href="https://blog.apnic.net/wp-content/uploads/2023/10/Chiplets-11.png">https://blog.apnic.net/wp-content/uploads/2023/10/Chiplets-11.png</a></p><h4>Tensor Cores and CUDA Cores</h4><p>When discussing the architecture and utility of Tensor Cores[3], we first need to discuss CUDA cores. CUDA (Compute Unified Device Architecture) is NVIDIA’s proprietary parallel processing platform and API for GPUs, while CUDA cores are the standard floating point unit in an NVIDIA graphics card. These have been present in every NVIDIA GPU released in the last decade as a defining feature of NVIDIA GPU microarchitectures. CUDA cores can significantly accelerate computation by executing processes in parallel. Because they can only operate on a single computation per clock cycle, GPUs are limited to the performance of CUDA cores and are also limited by the number of available CUDA cores on a chip and the clock speed of each core. To overcome this limitation, NVIDIA developed the Tensor Core.<br>In the context of GPU matrix operations, GPU Core Precision refers to the numerical formats that a GPU’s cores (Tensor Cores and CUDA Cores) can natively process. These precisions determine how numbers are represented and calculated during operations like matrix multiplication, which is fundamental to AI, ML, and HPC workloads.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/817/1*1cA7ycym3MMhTsFuNzh7Kw.png" /></figure><p>Note:</p><ul><li>Higher precision (e.g., FP64) = more accurate but slower and more memory-intensive.</li><li>Lower precision (e.g., INT8, FP8) = faster and more efficient, but may lose accuracy.</li></ul><h4>Tensor cores</h4><p>Recently NVIDIA’s Tensor Core microarchitecture evolution has become a key element of deep-learning workloads. Tensor cores are hardware units optimized for fused matrix multiply-add (FMA) operations. Fused multiply-add (FMA) is a single operation that performs both the multiply and add operations in one — the multiplication and addition are said to be “fused” together. FMA is typically faster than a separate multiplication and addition and produces more accurate results.</p><p>Unlike standard CUDA cores, Tensor Cores are optimized for high-throughput tensor computations of lower precision data types, enabling operations like matrix multiplication and accumulation at speeds that traditional GPU cores can’t match.<br>FMA operation computes the product of two tensors and adds that product to an accumulator in one step.<br>For example,<br>D=A×B+C<br>where A and B are input tensors, and C is the accumulation tensor and D is the result.</p><p>So in summary,</p><ul><li>CUDA Cores — CUDA Cores support a standard floating point precisions for more general-purpose GPU workloads.</li><li>Tensor Cores — Specialized for high-throughput matrix operations, especially for lower-precision formats to accelerate deep learning workload.</li></ul><h4>GPU Architectures and Core Precision</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/907/1*s0LQlgjxIpL0CtOvfZl2Nw.png" /></figure><h4>References</h4><p>1. <a href="https://www.tomshardware.com/tech-industry/artificial-intelligence/intel-launches-gaudi-3-accelerator-for-ai-slower-than-h100-but-also-cheaper">https://www.tomshardware.com/tech-industry/artificial-intelligence/intel-launches-gaudi-3-accelerator-for-ai-slower-than-h100-but-also-cheaper</a><br>2. <a href="https://www.semiconductor-digest.com/why-chiplet-based-architecture-is-the-next-frontier-in-semiconductors/">https://www.semiconductor-digest.com/why-chiplet-based-architecture-is-the-next-frontier-in-semiconductors/</a><br>3. <a href="https://www.digitalocean.com/community/tutorials/understanding-tensor-cores">https://www.digitalocean.com/community/tutorials/understanding-tensor-cores</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef8d74a4a227" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I think Bard with Gemini is superior to ChatGPT 3.5? [With examples]]]></title>
            <link>https://mlbits.medium.com/why-i-think-bard-with-gemini-is-superior-than-chatgpt-3-5-with-examples-f56dfcb7e757?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/f56dfcb7e757</guid>
            <category><![CDATA[google-gemini-ai]]></category>
            <category><![CDATA[google-gemini]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Sun, 10 Dec 2023 04:34:47 GMT</pubDate>
            <atom:updated>2025-07-31T04:01:31.299Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Google Gemini Bard OpenAI ChatGPT" src="https://cdn-images-1.medium.com/max/740/1*ksIGKafpz4PsLKiFvbjpEg.jpeg" /></figure><p>After a couple of false starts, Google has finally arrived with something serious. I am talking about Google Bard now with Gemini. I found it way smarter than ChatGPT.</p><p>First let me provide a couple of examples.</p><h3>Question 1</h3><h3><strong>In 1970s GE had about 40% market share in timeshare computer market. Why did they shifted away from computers business? Why did GE not invent new products and software for that market? Outline three key points supported by data.</strong></h3><p>ChatGPT 3.5 Answer:</p><blockquote>As of my last knowledge update in January 2022, I do not have specific data on GE’s market share in the timeshare computer market in the 1970s. However, I can provide some general insights into why companies, including General Electric (GE), might shift away from certain business sectors and fail to innovate in specific markets. Please note that the following points are based on general industry trends and business strategies and may not be specific to GE’s situation:</blockquote><blockquote><strong>1. Strategic Shifts and Focus on Core Competencies:</strong><br> — Companies often undergo strategic shifts to focus on their core competencies and areas where they have a competitive advantage. If GE determined that the timeshare computer market was not aligned with its core strengths or strategic goals, it might have chosen to divest from that business.<br> — Resource allocation is a crucial factor. If GE found more lucrative opportunities in other sectors or if the timeshare computer market was not yielding sufficient returns, the company might have decided to reallocate resources to more promising areas.</blockquote><blockquote><strong>2. Market Dynamics and Technological Changes:</strong><br> — The 1970s marked a period of rapid technological change in the computer industry, with the emergence of personal computers and other advancements. If GE failed to adapt to these changes or invest adequately in research and development to keep up with evolving technologies, it could have lost its competitive edge in the timeshare computer market.<br> — Companies that do not innovate or adapt to changing market dynamics risk becoming obsolete. If GE did not invest in new products and software for the timeshare computer market, it might have lost relevance as competitors introduced more advanced and efficient solutions.</blockquote><blockquote><strong>3. Financial Performance and Profitability:</strong><br> — Financial considerations play a significant role in business decisions. If the timeshare computer business was not profitable for GE or did not contribute significantly to the overall financial performance of the company, it might have chosen to exit that market.<br> — Companies often prioritize investments in areas with higher growth potential and profitability. If GE assessed that its resources could generate better returns in other industries or business segments, it might have made a strategic decision to exit the timeshare computer market.</blockquote><blockquote>It’s important to note that the specifics of GE’s decision would require a detailed examination of historical records, financial reports, and strategic documents from that time period. Additionally, industry experts and historians could provide more nuanced insights into the factors influencing GE’s decisions during the 1970s.</blockquote><p>Bard Answer:</p><blockquote><strong>GE’s Departure from the Computer Business: Three Key Points</strong></blockquote><blockquote>1. Missed Market Shifts:</blockquote><blockquote>Mainframe decline: By 1975, mainframe shipments were already declining, while minicomputers and personal computers were experiencing explosive growth. GE remained focused on mainframes, losing out on the rapidly growing new markets.</blockquote><blockquote>Data: Between 1970 and 1975, mainframe shipments dropped by 20%, while minicomputer shipments grew by 500%. (Source: International Data Corporation)</blockquote><blockquote>2. Internal Issues Hindered Innovation:</blockquote><blockquote>Leadership instability: The GE computer division went through four leadership changes in the 1970s, leading to a lack of clear strategic direction and hindering innovation.</blockquote><blockquote>Data: The average tenure of GE’s computer division head was less than two years during the 1970s. (Source: Internal GE documents)</blockquote><blockquote>3. Strategic Mistakes and Missed Opportunities:</blockquote><blockquote>Focus on hardware over software: GE neglected software development, a crucial element in the evolving computer industry.</blockquote><blockquote>Data: GE’s software division accounted for only 10% of the computer division’s revenue in 1975. (Source: GE annual report)</blockquote><blockquote>Failed investment in new technologies: GE missed the potential of microprocessors, which ultimately led to the decline of mainframes.</blockquote><blockquote>Data: GE invested less than 1% of its computer division’s revenue in microprocessor research in 1975. (Source: Internal GE documents)</blockquote><blockquote>These factors, combined with intense external competition, ultimately led GE to shift away from the computer business despite their early success in the timeshare market. While they attempted to innovate, their efforts were ultimately hampered by their internal struggles and strategic missteps.</blockquote><h3>Question 2</h3><h3>List down how the sub-segments in the SASE (secure access service edge) products offering is organised. List market-size, growth potential and rank key players by order of their marketshare in each of the sub-segments.</h3><p>ChatGPT Answer:</p><blockquote>As of my last knowledge update in January 2022, specific market sizes, growth potentials, and rankings for key players in each sub-segment of the Secure Access Service Edge (SASE) market are not readily available in this format. Market conditions are dynamic, and detailed data can change rapidly. For the most accurate and up-to-date information, please consult the latest industry reports, market analyses, and research studies. However, I can provide a general outline of the sub-segments and key players without specific market share rankings:</blockquote><blockquote><strong>1. Secure Web Gateways (SWGs):</strong><br> — Market Size: Significant, driven by the increasing need for web security, but specific figures may vary.<br> — Growth Potential: High growth potential due to evolving web-based threats and the critical role of secure internet access.<br> — Key Players: Cisco Umbrella, Zscaler, Symantec (now part of Broadcom), McAfee, and others.</blockquote><blockquote><strong>2. Cloud Access Security Brokers (CASBs):</strong><br> — Market Size: Substantial, reflecting the importance of securing data in transit between on-premises and cloud environments.<br> — Growth Potential: Significant growth potential as organizations continue to adopt cloud services and seek robust data protection solutions.<br> — Key Players: Netskope, Bitglass, Microsoft Cloud App Security, Symantec CloudSOC, and others.</blockquote><blockquote><strong>3. Zero Trust Network Access (ZTNA):</strong><br> — Market Size: Growing, driven by the transition to Zero Trust security models, but specific market size figures may vary.<br> — Growth Potential: Considerable growth potential as more enterprises recognize the need for secure access to applications and data.<br> — Key Players: Akamai, Palo Alto Networks (Prisma Access), Zscaler Private Access, Cato Networks, and others.</blockquote><blockquote><strong>4. Firewall as a Service (FWaaS):</strong><br> — Market Size: Notable, reflecting the demand for flexible and scalable cloud-based firewall solutions.<br> — Growth Potential: High growth potential as organizations seek advanced firewall capabilities delivered from the cloud.<br> — Key Players: Check Point, Palo Alto Networks (Prisma Access), Fortinet, and others.</blockquote><blockquote>To obtain detailed market share rankings, it’s advisable to refer to reports and analyses from reputable research firms and market intelligence sources. Gartner Magic Quadrant, Forrester Wave, and other industry-specific reports are often used to assess the performance and market position of key players in the cybersecurity landscape. Keep in mind that the competitive landscape can evolve, and newer reports will provide the most accurate and current insights.</blockquote><p>Bard Answer</p><blockquote>SASE Sub-segments and Key Players:</blockquote><blockquote><strong>1. Secure Web Gateway (SWG):</strong></blockquote><blockquote>Market Size: $4.5 billion (2023)</blockquote><blockquote>Growth Potential: 25% CAGR (2023–2028)</blockquote><blockquote>Key Players:</blockquote><blockquote>Zscaler (35% market share)</blockquote><blockquote>Cisco (18% market share)</blockquote><blockquote>Palo Alto Networks (13% market share)</blockquote><blockquote>Symantec (12% market share)</blockquote><blockquote>Fortinet (10% market share)</blockquote><blockquote><strong>2. Cloud Access Security Broker (CASB):</strong></blockquote><blockquote>Market Size: $3.2 billion (2023)</blockquote><blockquote>Growth Potential: 20% CAGR (2023–2028)</blockquote><blockquote>Key Players:</blockquote><blockquote>Microsoft (25% market share)</blockquote><blockquote>McAfee (20% market share)</blockquote><blockquote>Netskope (15% market share)</blockquote><blockquote>Zscaler (12% market share)</blockquote><blockquote>Symantec (10% market share)</blockquote><blockquote><strong>3. Zero Trust Network Access (ZTNA):</strong></blockquote><blockquote>Market Size: $1.8 billion (2023)</blockquote><blockquote>Growth Potential: 30% CAGR (2023–2028)</blockquote><blockquote>Key Players:</blockquote><blockquote>Palo Alto Networks (25% market share)</blockquote><blockquote>Zscaler (20% market share)</blockquote><blockquote>Cloudflare (18% market share)</blockquote><blockquote>Fortinet (15% market share)</blockquote><blockquote>Microsoft (12% market share)</blockquote><blockquote><strong>4. Firewall as a Service (FWaaS):</strong></blockquote><blockquote>Market Size: $2.4 billion (2023)</blockquote><blockquote>Growth Potential: 22% CAGR (2023–2028)</blockquote><blockquote>Key Players:</blockquote><blockquote>Palo Alto Networks (28% market share)</blockquote><blockquote>Fortinet (22% market share)</blockquote><blockquote>Cisco (17% market share)</blockquote><blockquote>Check Point Software Technologies (15% market share)</blockquote><blockquote>CloudGenix (10% market share)</blockquote><blockquote><strong>5. Secure SD-WAN:</strong></blockquote><blockquote>Market Size: $1.2 billion (2023)</blockquote><blockquote>Growth Potential: 35% CAGR (2023–2028)</blockquote><blockquote>Key Players:</blockquote><blockquote>VMware (25% market share)</blockquote><blockquote>Cisco (20% market share)</blockquote><blockquote>Palo Alto Networks (15% market share)</blockquote><blockquote>Fortinet (12% market share)</blockquote><blockquote>Silver Peak Systems (10% market share)</blockquote><blockquote>Note: These are estimates based on various industry reports and analysis. The actual market size, growth potential, and market share for individual players may vary.</blockquote><h3>Conclusion</h3><p>It seems that Bard has an edge over ChatGPT in multiple ways:</p><ol><li>Bard organising the answer logically as requested</li><li>It uses an analytical reasoning in answering complex questions</li><li>It provides data when necessary. This, in my opinion, is an unsurmountable advantage for most competitors of Bard. Google’s ability to organize the worlds data is an established competitive advantage, attributed to the the Google search engine. OpenAI + Microsoft would in theory have access to Github, linkedin and Bing data. However in this round, the speed of execution is in Google’s favor.</li></ol><p>Note: I did not go back and verify the data produced by Bard or ChatGPT. This comparison is based on facevalue of the responses.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f56dfcb7e757" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Machine Learning 101–in less than 10 mins]]></title>
            <link>https://mlbits.medium.com/machine-learning-101-1bba1826db90?source=rss-4c51234fe872------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bba1826db90</guid>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[aiml]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ml-for-dummies]]></category>
            <category><![CDATA[mls]]></category>
            <dc:creator><![CDATA[Santanu Dey]]></dc:creator>
            <pubDate>Tue, 27 Dec 2022 02:18:32 GMT</pubDate>
            <atom:updated>2023-01-17T03:14:47.436Z</atom:updated>
            <content:encoded><![CDATA[<p>ML as a subject is extremely vast and the skills required to be a practitioner in any of the sub-fields of ML is truely intimidating. But for most of us an 101 level common knowledge of ML is quintessential to be able to navigate and understand this field. If you have 10 mins to spare, you will walk away with a basic understanding of the AIML space today in 2022–23.</p><p>Machine Intelligence Require that an algorithm be able to</p><ol><li>Acquire knowledge from data</li><li>Apply that knowledge to make inferences</li></ol><h3>What are the common types of ML algorithms?</h3><ul><li>Supervised<br>- Regression problem<br>- Classification problem</li><li>Unsupervised<br>- Clustering problem<br>- Dimensionality Reduction problem</li><li>Semi-Supervised <br>- When you have a small set of data with labels, you can generate a model with that smaller dataset and then with that trained model generate labels for a larger dataset with missing labels for supervised learning. Often used with deep learning use cases.</li><li>Reinforcement <br>- Learning optimal response by trial and error and getting a feedback</li></ul><h3>How to implement an ML solution?</h3><p>Machine learning starts with a business problem being addressed by use of data. When the entire process is broken down into stages (often iterative), you get the following stages:</p><h4>Business Sponsorship</h4><ol><li><strong>Business Problem: </strong>A business problem is your motivation to start an effort with AI/Ml.</li><li><strong>Frame ML Problem : </strong>You should always define the success metrics in terms of business outcomes that can be clearly measured.</li></ol><p>Once there is such well defined business problem and sponsorship to embark on the ML journey — then you look at getting the right set of data.</p><h4>Data Engineering</h4><ol><li>Identify valuable data sources</li><li>Collect Data &amp; then Integrate data in the ML pipeline <br>- This is called Data Ingestion</li><li>Data Preparation <br>This involves <br>- Data Analysis <br>- Data Transformation<br>- Data Cleaning e.g. <br><strong>(a) Handling Missing values</strong> — imputation is a technique to replace a missing value with a value from the data set. Alternately, you can throwaway such data points with missing values. <br> <strong>(b) Ordered data </strong>— May need to shuffle the data to remove order.<br><strong> (c) Handling outliers </strong>— usually removed.</li><li>Test / Validation / Training data — This usually involves splitting the available dataset for training, testing and validation. This technique of splitting is called cross-validation. There are some common techniques such as :<br>- Randomly split a part of the data and train the rest — called validation technique. This way some significant data is unseen by the model when training. <br>- Leave one out (LOO) — each time train the model by leaving out one record for validation. Finally select the model that has least amount of error. This is computationally very expensive. <br>- K-fold — split the data in k-sets/folds. Then train (k-1) set of data folds each time and record the validation error.</li><li>Data visualization — e.g. Scatter diagram, Histogram for ease of understanding the nature of the data.</li></ol><p><strong><em>Who is responsible for the data engineering work for Machine Learning? </em></strong><br>This part of the ML workflow involves data engineering teams. Once data is available in a useful form for exploration and ML modeling, the next step is for data scientists to experiment with building an appropriate ML model that can satisfy the business requirements.</p><h4>Data Science Workflow</h4><p>Data science workflow broadly involves the following stages:</p><ol><li>Feature Engineering -&gt; raw data to higher level of representation of features. <br> — Binning (categorizing continuous data into discrete classes) Combining one or more simple feature into one <br>- transform by taking log, polynomial power of feature values or target variables to make it more linear<br>- Data encoding <br>- Text feature engineering — (a) remove stop words (stemming), punctuation (b) lowercasing (c) cutting off very high or very low percentile frequency words (d) Term-Frequency Inverse-Document-Frequency (TF-IDF) <br>- Identify correct data biases and imbalances</li><li>Model Training <br>- Parameter tuning <br>- Loss Function — a formula to calculate error of a model prediction for a data set. <strong>(a) Square </strong>— regression, classification <strong>(b) Hinge</strong> — for classification only, robust for outliers <strong>(c) Logistic</strong> — for classification only — better for skewed class distribution<br>- Regularization — to better fit the unseen data. Reduce overfitting. <br>- Learning parameter. The objective is to set an appropriate value so that the training algorithm converges to a proper fit. Otherwise you end up with a situation where the parameter is (a) Decaying too aggressively — when algorithm does not find the optimum fit. (b) Decaying too slowly — and then the algorithm bounces around, does not converge to optimum fit.</li><li>Model evaluation is required to take care of<br>- Over-fitting and under-fitting<br>- Bias-Variance Trade-off — Bias is distance between actual and predicted values. Variance is variation in prediction across data samples. If all errors are in the same direction then the model is highly biased. If the errors are scattered in all direction then bias is low. Variance is high if the error is high for most data points. Variance is low if error is low across most data points. This is a good measure of fitting too. <br>- Evaluation metrics provides a numerical way to quantify the fit. A number of common metrics are: <br> 1. Root Mean Square Error (RMSE)<br> 2. Mean Absolute Path Error (MAPE)<br> 3. R2 — compare the model against the best picked constant <br> 4. For classification problem — one can use <br> a. Confusion Matrix<br> b. ROC curve <br> c. Precision-Recall</li><li>ML workflow is iterative. Often to get a better result more data is needed. That is — Data Augmentation / Feature Augmentation.</li></ol><p><strong><em>Who is responsible for the data science work for Machine Learning?</em></strong></p><p>All the above techniques require deep knowledge in the respective branch of Data Science. E.g., if you are dealing with textual natural language, or image recognition — these skills are very specialized.</p><h4><a href="https://mlbits.medium.com/what-problems-do-mlops-solve-7cc06726dc65">ML Operations</a></h4><p>ML workflow does not end at finding a satisfactory model. It also involves the following</p><ol><li>Tracking all ML artifacts including features, ML model inputs such as hyperparameters, ML model versions and evaluation metrics.</li><li>Model Deployment, usually also needs automation for: <br> a. Re-trained and continuous delivery <br> b. A/B testing, blue green deployment <br> c. Optimal resource utilization &amp; auto-scaling</li><li>Model Monitoring <br>1. Business goal metrics <br>2. Technical monitoring — Model Drift over time.<br>3. Non-functional monitoring such as performance, security aspects etc.</li></ol><p><strong><em>Who is responsible for the operations work for Machine Learning?</em></strong></p><p>ML Engineer or MLOPs Engineer or DevOps Engineers roles are involved in the deployment, monitoring, automation and such platform aspects of Machine Learning workload production.</p><p>Also read: <a href="https://mlbits.medium.com/what-problems-do-mlops-solve-7cc06726dc65">What Problems Do ML Ops Solve?</a></p><h3>Roles involved in Machine Learning</h3><p>As described in the respective sections above you are primarily looking at the following roles</p><ul><li>Business SME</li><li>Data Engineers</li><li>Data Scientists</li><li>MLOps / ML Engineers</li></ul><p>Apart from these roles you may also need Product Managers, Documentation Engineers, Project Managers, Scrum Masters etc.</p><p>Also read: <a href="https://mlbits.medium.com/how-to-set-up-a-ml-saas-paas-product-team-22c784b3b36c">How to set-up a ML SaaS/PaaS Product Team</a></p><h3>How do I get started?</h3><ol><li>Start from a specific role in ML projects — e.g., MLOps, Data Scientist, Data Engieer or SME who understands the business domain.</li><li>Specialize on a subfield in ML<br>As ML is vast field, it is important to identify a sub-area of ML to start building knowledge/skills. But you still need to know the fundamental elements of Data Science.</li></ol><p>A wide variety of common business use cases can be solved with AI and ML. Below is a simple list of common problems that are getting implemented widely using AI/ML.</p><figure><img alt="Common ML (machine learning) use cases" src="https://cdn-images-1.medium.com/max/1024/1*YyFK1m_OlTC6ou9N0cQr2A.png" /></figure><p>Sometime multiple techniques are required to be applied to address a real-life use case.</p><p>As a reference to the common use cases, I found this insightful view based software revenue. This is a more practical view of what is in-demand:</p><h3>Mike Quindazzi on Twitter: &quot;Top 10 #AI use-cases ranked by #ArtificialIntelligence software revenues &gt;&gt;&gt; @tractica via @MikeQuindazzi &gt;&gt;&gt; #MachineLearning #DeepLearning #ComputerVision #NLP #NLG #DataScience #4IR &gt;&gt;&gt; https://t.co/3qp5a7Wkl4 pic.twitter.com/mishk1atPP / Twitter&quot;</h3><p>Top 10 #AI use-cases ranked by #ArtificialIntelligence software revenues &gt;&gt;&gt; @tractica via @MikeQuindazzi &gt;&gt;&gt; #MachineLearning #DeepLearning #ComputerVision #NLP #NLG #DataScience #4IR &gt;&gt;&gt; https://t.co/3qp5a7Wkl4 pic.twitter.com/mishk1atPP</p><p>Many of the above use cases involves unstructured data types such as text, image, audio &amp; video — which often requires deep-learning capabilities involving specialized hardware and software such as programs embedded into cameras, GPUs especially for image and video use cases. <br>Deep-learning or statistical machine learning algorithms all require vector algebra or linear algebra. This is because</p><ol><li>Computer understands, stores and processes all data as forms of 0 and 1s. For example, each pixel in an image has an intensity value that ranges from 0 to 255. A value of 0 represents a black pixel and 255 represents a white pixel.</li><li>Most of the ML &amp; deep learning algorithms deal with such vector representation of data.</li></ol><p>So in summary, you will need embark on a learning journey involving:</p><p>a) Learning the ML algorithms in your chosen sub-field &amp; understanding the mathematical basics behind those <br>b) hands-on knowledge of tools and frameworks for implementing your use cases.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bba1826db90" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>