<?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 Movses Aleksanyan on Medium]]></title>
        <description><![CDATA[Stories by Movses Aleksanyan on Medium]]></description>
        <link>https://medium.com/@movsesaleksanyan7?source=rss-7b012040e1e7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KpSCUZ1HuH1inqMmlAb74g.png</url>
            <title>Stories by Movses Aleksanyan on Medium</title>
            <link>https://medium.com/@movsesaleksanyan7?source=rss-7b012040e1e7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 06:44:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@movsesaleksanyan7/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[Building Stripe-Like Idempotency for ASP.NET Core: Design, Tradeoffs, and Production Lessons]]></title>
            <link>https://medium.com/@movsesaleksanyan7/building-stripe-like-idempotency-for-asp-net-core-design-tradeoffs-and-production-lessons-938fd2d9273c?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/938fd2d9273c</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[aspnetcore]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[api-design]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Sat, 28 Mar 2026 11:06:00 GMT</pubDate>
            <atom:updated>2026-03-28T11:06:00.646Z</atom:updated>
            <content:encoded><![CDATA[<p>Many APIs are easy to write, but hard to make reliable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5ZJADrN-LXYFJ-fz7Uc2YQ.gif" /></figure><p>If a client times out and retries, your API can accidentally charge a credit card twice, create duplicate orders, or trigger the same side effect multiple times. In distributed systems, retries aren’t an exception; they are the norm. Duplicate side effects, however, are a disaster.</p><p>I built IdempotencyKey.AspNetCore to solve this problem in a practical, production-ready way for ASP.NET Core.</p><p>The goal was simple:</p><ul><li><strong>Same request + same idempotency key</strong> = Same response (Replay)</li><li><strong>Same key + different request</strong> = Conflict (Reject)</li></ul><p>This article explains the architecture, key design decisions, and what I learned while building an open-source, Stripe-like idempotency package.</p><h3>Why Idempotency Matters</h3><p>If your endpoint has side effects, idempotency isn’t an optional feature — it’s a fundamental part of system correctness.</p><p>Consider the realities of modern networks:</p><ul><li><strong>Clients retry</strong> because networks momentarily drop.</li><li><strong>Load balancers retry</strong> because upstream services are slow.</li><li><strong>Mobile apps replay requests</strong> when transitioning between cell towers and Wi-Fi.</li></ul><p>Payment and order systems simply cannot tolerate duplicates. You need a way to ensure that a retry is treated as a safe recovery mechanism, not a new transaction.</p><h3>What IdempotencyKey.AspNetCore Does</h3><p>I wanted a library that felt native to modern .NET, meaning it needed to be Native AOT friendly, support Minimal APIs out of the box, and be highly configurable.</p><p>Here is what the package brings to the table:</p><ul><li><strong>Stripe-like Semantics:</strong> Adds Idempotency-Key header validation to your endpoints.</li><li><strong>Full Response Snapshots:</strong> Stores the status, safe headers, and body for accurate replay.</li><li><strong>Conflict Detection:</strong> Detects key reuse with fingerprint mismatches and returns a 409 Conflict.</li><li><strong>Concurrency Control:</strong> Handles in-flight duplicates by waiting or returning an immediate retry signal.</li><li><strong>Storage Agnostic:</strong> Works seamlessly with Memory, Redis, and Postgres providers.</li></ul><h3>The Core Execution Model</h3><p>When a request hits an idempotent endpoint, the execution flow looks like this:</p><ol><li><strong>Validate:</strong> Check the Idempotency-Key header.</li><li><strong>Fingerprint:</strong> Compute a SHA-256 hash of the request (method + route + selected headers + raw body).</li><li><strong>TryBegin in Store:</strong></li></ol><ul><li><em>Acquired:</em> Execute the handler and store the response snapshot.</li><li><em>AlreadyCompleted:</em> Replay the stored snapshot back to the client.</li><li><em>Conflict:</em> Fingerprint mismatch! Return 409 Conflict.</li><li><em>InFlight:</em> Another request with this key is currently processing. Wait (or return an immediate Retry-After response).</li></ul><p>The most important guarantee here is <strong>deterministic behavior under retries</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YpfSCVoqpJnjC5BE32CssA.png" /></figure><h3>Design Choices I Made</h3><p>Building a package for production means making opinionated design choices. Here are the major ones:</p><h3>1. Fingerprints include route, method, headers, and a body hash</h3><p>It is incredibly common for a bug on the client side to accidentally reuse the same idempotency key for an entirely different request. By hashing the payload (up to a configurable 1MB limit), the package avoids false positives and rejects accidental key reuse.</p><h3>2. Snapshot replay stores the full response body</h3><p>Replaying <em>only</em> the HTTP status code is rarely enough for real-world clients. If a mobile app retries a payment creation, it needs the newly generated PaymentId back in the JSON body. The package stores up to 256KB of response data to ensure the client gets the exact same experience on a retry.</p><h3>3. Provider-agnostic store contracts</h3><p>Different environments have different needs. I implemented the exact same semantics across three providers:</p><ul><li><strong>In-Memory:</strong> Perfect for local dev and fast unit/integration testing.</li><li><strong>Redis:</strong> For low-latency, high-throughput distributed systems.</li><li><strong>Postgres:</strong> For durable, transactional environments (using INSERT ... ON CONFLICT).</li></ul><h3>4. Configurable in-flight policies</h3><p>Concurrency is tricky. If two requests with the same key arrive at the exact same millisecond, what should the API do? Different products prefer different behaviors. The package allows you to configure whether to <strong>wait</strong> for the first request’s completion (defaulting to 10 seconds), or <strong>return quickly</strong> and let the client retry later via a Retry-After header.</p><h3>How to Use It</h3><p>I designed the API to be as frictionless as possible.</p><p><strong>For Minimal APIs</strong>, you simply append .RequireIdempotency() to your endpoints or groups:</p><pre>var builder = WebApplication.CreateSlimBuilder(args);<br>builder.Services.AddIdempotencyKey(); <br>builder.Services.AddSingleton&lt;IIdempotencyStore, MemoryIdempotencyStore&gt;(); <br><br>var app = builder.Build();<br>app.UseIdempotencyKey(); // Required for Model Binding<br><br>app.MapPost(&quot;/payments&quot;, (PaymentRequest req) =&gt;<br>{<br>    // Process payment safely...<br>    return Results.Ok(new { Status = &quot;Processed&quot;, Id = Guid.NewGuid() });<br>})<br>.RequireIdempotency(options =&gt;<br>{<br>    options.Ttl = TimeSpan.FromMinutes(60);<br>});<br><br>app.Run();</pre><p><strong>For MVC Controllers</strong>, you can use the [RequireIdempotency] attribute:</p><pre>[ApiController]<br>[Route(&quot;[controller]&quot;)]<br>public class PaymentsController : ControllerBase<br>{<br>    [HttpPost]<br>    [RequireIdempotency(TtlSeconds = 60)]<br>    public IActionResult Create([FromBody] PaymentRequest request)<br>    {<br>        return Ok(new { Status = &quot;Processed&quot; });<br>    }<br>}</pre><h3>Production Lessons Learned</h3><p>Building this wasn’t just an exercise in writing middleware; it was an exercise in understanding distributed state.</p><ul><li><strong>Idempotency is not just a middleware problem:</strong> You need endpoint semantics, storage semantics, and timeout semantics all aligned. If your database transaction times out but your idempotency key is marked as complete, you have a split-brain scenario.</li><li><strong>Error contract customization is essential:</strong> Every engineering team already has an API error model (e.g., Problem Details). Forcing a generic error shape on users doesn’t work. I had to build global error response writers so teams could map IdempotencyErrorKind.Conflict to their own custom JSON schemas.</li><li><strong>Storage key design matters a lot:</strong> A tiny bug in how you format a cache key can become a massive correctness bug in distributed systems.</li><li><strong>Defaults must be safe, docs must be explicit:</strong> Most adoption friction comes from unclear behavior, not missing features.</li></ul><h3>Final Thoughts</h3><p>Reliability is not just about uptime. It is also about correctness when the network lies to you.</p><p>Idempotency gives your API a memory of intent. That memory turns retries from a dangerous risk into a safe, deterministic operation. If you are building side-effecting APIs in ASP.NET Core — especially for payments, bookings, or order management — idempotency should be a first-class concern, not a patch applied after an incident.</p><p><strong>Want to try it out?</strong> You can find the package on NuGet (IdempotencyKey.AspNetCore) and check out the source code, benchmarks, and roadmap on <a href="https://github.com/movsal08/IdempotencyKey">[GitHub Link Here]</a>.</p><p><em>Start with the Memory store for local verification, move to Redis/Postgres for production, and stop worrying about duplicate requests!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=938fd2d9273c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Truth About Best Practices No One Wants to Admit]]></title>
            <link>https://medium.com/@movsesaleksanyan7/the-truth-about-best-practices-no-one-wants-to-admit-b5c6b6b7b729?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/b5c6b6b7b729</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Sat, 24 May 2025 10:02:09 GMT</pubDate>
            <atom:updated>2025-05-24T10:03:57.551Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>“We followed all the best practices — and still failed.”</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LL8SIt0yKF1ZPYQRCzLn-g.png" /></figure><p>That’s how one .NET team described their two-year detour through microservice hell, after dismantling a rock-solid monolith in pursuit of architecture purity. The kicker? They ended up rewriting it all back into a modular monolith just to make it usable again.</p><p>In today’s engineering culture, <em>best practices</em> are treated as gospel. But what if they’re not always best? What if they sometimes prevent smart, context-aware decisions — and even contribute to team dysfunction and burnout?</p><h3>🧨 When Best Practices Become Pitfalls</h3><p>Let’s unpack a few real-world .NET examples:</p><h3>1. Microservices by the Book — Disaster in Practice</h3><p>A .NET SaaS team split a perfectly functioning monolith (99.97% uptime) into eight services after reading too much architectural theory. Result?</p><ul><li><strong>6 months lost</strong></li><li><strong>New integration bugs</strong></li><li><strong>Team burnout</strong></li></ul><p>They later admitted: the shift was driven more by “what good engineers are supposed to do” than what the business actually needed.</p><h3>2. Clean Architecture Overload</h3><p>James Hickey, a .NET architect, implemented Clean Architecture with rigor — but found it scattered logic so far apart that simple changes required touching four files in four layers.<br> He later switched to a <strong>vertical slice</strong> model: grouping features by business use-case, not technical layer. It sped up development and reduced mistakes.</p><h3>3. SOLID Worship = Over-Abstracted Chaos</h3><p>In one team, applying DRY and SRP too aggressively led to a web of interfaces and tiny classes no one could understand.<br> Quote from a teammate:</p><blockquote><em>“Everything called something else. Tracing logic was like solving a riddle.”</em></blockquote><h3>🔍 The Hidden Cost of Architectural Dogma</h3><p>Following best practices <strong>without context</strong> introduces:</p><ul><li><strong>Cognitive overload:</strong> Devs spend more time deciphering layers than solving problems.</li><li><strong>Velocity decay:</strong> Simple changes require excessive ceremony.</li><li><strong>False confidence:</strong> “We’re SOLID-compliant” doesn’t mean “our system is good.”</li></ul><blockquote><em>🧠 </em>Mark Seemann’s advice? Don’t inject everything. Design to reject dependencies entirely.</blockquote><h3>✅ Conscious Tradeoffs &gt; Blind Practices</h3><p>Instead of asking “Is this best practice?”, ask:</p><ul><li>Does this pattern <strong>actually help us</strong> solve today’s problem?</li><li>Are we <strong>adding complexity</strong> for a future that may never come?</li><li>Could a simpler approach be <strong>more maintainable</strong> for our team?</li></ul><h3>Embrace Tradeoffs Like:</h3><ul><li><strong>Monoliths first, microservices later</strong> — only if scale demands it.</li><li><strong>Vertical slices over rigid layers</strong> — keep logic cohesive and understandable.</li><li><strong>Tests that matter</strong> — not just high coverage, but high confidence.</li></ul><h3>💡 Teams That Got It Right</h3><ul><li><strong>Amazon Prime Video</strong> re-architected a microservices-based video pipeline back into a <strong>monolith</strong> and saved 90% on AWS costs.</li><li><strong>Small .NET teams</strong> ditched over-abstracted layering and instead focused on delivering <strong>modular features</strong> with business impact.</li><li><strong>Pragmatic devs</strong> rejected patterns that made their code less readable — even if they ticked the “enterprise architecture” boxes.</li></ul><h3>🧠 Final Takeaway</h3><p><strong>Best practices are tools — not commandments.</strong><br> When they align with your context, use them. When they don’t, challenge them.</p><p>The real “best practice” is this:<br> 👉 <em>Make conscious tradeoffs that serve your team, your product, and your users — not just your architecture diagram.</em></p><p><strong>Sources:</strong></p><ul><li>Real-world microservices failure and monolith success stories<a href="https://medium.com/devs-community/how-we-wasted-6-months-on-microservices-we-didnt-need-c36e26c5e3cf#:~:text=In%20the%20fall%20of%202022%2C,ourselves%20we%20were%20falling%20behind">medium.com</a> <a href="https://www.reddit.com/r/dotnet/comments/1ee2z5s/common_approach_to_building_out_microservices_in/#:~:text=I%20would%20take%20a%20look,to%20very%2C%20very%20small%20microservices">reddit.com</a></li><li>Reddit discussion with .NET developers on microservices vs. monolith trade-offs <a href="https://www.reddit.com/r/dotnet/comments/1ee2z5s/common_approach_to_building_out_microservices_in/#:~:text=True,project%20to%20use%20micro%20services">reddit.com</a></li><li>Amazon Prime Video case study on re-monolithing for efficiency <a href="https://devclass.com/2023/05/05/reduce-costs-by-90-by-moving-from-microservices-to-monolith-amazon-internal-case-study-raises-eyebrows/#:~:text=save%20money%20by%20moving%20from,Functions%20and%20Lambda%20serverless%20functions">devclass.com</a><a href="https://devclass.com/2023/05/05/reduce-costs-by-90-by-moving-from-microservices-to-monolith-amazon-internal-case-study-raises-eyebrows/#:~:text=An%20Amazon%20case%20study%20from,Functions%20and%20Lambda%20serverless%20functions">devclass.com</a></li><li>James Hickey’s critique of Clean Architecture (excessive layering issues) <a href="https://www.jamesmichaelhickey.com/clean-architecture/#:~:text=The%20usual%20way%20that%20developers,implement%20clean%20architecture%20is%20horrible">jamesmichaelhickey.com</a></li><li><em>SOLID, KISS, DRY… suck</em> — Medium article on overusing principles (DRY, SRP pitfalls) <a href="https://medium.com/@iamprovidence/solid-kiss-dry-and-other-principles-suck-55c6758322a2#:~:text=I%E2%80%99ve%20been%20on%20a%20project,code%20I%20have%20ever%20seen">medium.com</a></li><li>Michael Plöd on DDD pitfalls (warning against cargo-culting patterns) <a href="https://medium.com/@philippkostyra/failures-and-lessons-learned-from-using-domain-driven-design-ddd-insights-from-michael-pl%C3%B6d-b2cdb6cd7a80#:~:text=value%20of%20iteration%2C%20adaptation%2C%20and,the%20DDD%20Starter%20Modelling%20Process">medium.com</a></li><li>Dev.to story “Why I Don’t Do TDD” — TDD overuse slowing a project <a href="https://dev.to/codenameone/why-i-dont-do-tdd-1j71#:~:text=The%20big%20claim%20for%20TDD,that%20most%20weren%E2%80%99t%20even%20automatic">dev.to</a><a href="https://dev.to/codenameone/why-i-dont-do-tdd-1j71#:~:text=But%20the%20real%20problem%20was,testing%20performed%20after%20the%20fact">dev.to</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b5c6b6b7b729" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why “Scalable” Is the Most Abused Word in Engineering ]]></title>
            <link>https://medium.com/@movsesaleksanyan7/why-scalable-is-the-most-abused-word-in-engineering-43a1d4392539?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/43a1d4392539</guid>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[startup-culture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Tue, 06 May 2025 11:12:16 GMT</pubDate>
            <atom:updated>2025-05-06T11:12:16.868Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c_Xp32E-31iEdi1Ekux44Q.png" /></figure><h3>📖 Introduction</h3><p>Every tech pitch deck since 2010 has promised “infinite scalability.” But what does “scalable” even mean? Too often, it’s become marketing glitter rather than a concrete engineering goal. In reality, chasing scalability before you truly need it can lead to over-engineering, wasted resources, and delayed launches. Let’s unpack the hype and learn how teams at Basecamp and GitHub focus on measured growth instead of mythical “infinite scale.”</p><h3>🔍 Startup Myths vs. Hard Metrics</h3><ul><li><strong>Myth:</strong> “Our platform must handle millions of users Day One.”</li><li><strong>Reality:</strong> 90% of startups plateau under 10 K daily active users in year 1.</li><li><strong>Cost of Premature Scaling:</strong></li><li>Complex microservices → higher latency and debugging overhead.</li><li>Over-provisioned infrastructure → 2–3× inflated AWS bills.</li><li><strong>Case in Point:</strong> A Series A social app spent six months building a Kubernetes cluster before launch — only to find their monthly traffic hovered under 1 K users, making their entire platform unnecessarily complex.</li></ul><h3>📊 How Basecamp and GitHub Do “Scaling” Differently</h3><h3>1. Basecamp’s 37signals Philosophy</h3><ul><li><strong>Keep It Simple:</strong> Single-instance servers, minimal dependencies.</li><li><strong>Measure First:</strong> They track real traffic peaks before architecting horizontal scaling.</li><li><strong>Fail-Fast Scaling Tests:</strong> Simulate load on staging; scale only when real patterns emerge.</li></ul><h3>2. GitHub’s Pragmatic Growth</h3><ul><li><strong>Data-Driven Sharding:</strong> They shard repos by actual usage patterns, not arbitrary thresholds.</li><li><strong>Graceful Degradation:</strong> During traffic spikes, non-critical features (e.g., code search) are throttled, keeping core operations alive.</li><li><strong>Invest Where It Counts:</strong> Instead of auto-scaling every service, they focus ops on their core data stores and API gateway.</li></ul><h3>⚖️ Alternatives to Premature “Scalability”</h3><p><strong>1. Vertical Scaling First</strong></p><ul><li>Start with beefier instances (more CPU/memory) before splitting services.</li><li>Example: A real-estate SaaS doubled its EC2 size to handle holiday listing surges, avoiding microservice complexity.</li></ul><p><strong>2. Feature Flags &amp; Throttling</strong></p><ul><li>Gate resource-heavy features behind flags to limit unexpected load.</li><li>Case Study: A fintech API gated fiscal-year end reports, unlocking them only after off-peak hours.</li></ul><p><strong>3. Clear Service Boundaries</strong></p><ul><li>Instead of 15 microservices at launch, start monolithic and extract only when a service hits measurable bottlenecks.</li><li>Common Mistake: Over-modularizing for theoretical scale, resulting in cross-service latency woes.</li></ul><h3>🧠 Common Pitfalls &amp; How to Avoid Them</h3><ul><li><strong>Premature Microservices:</strong> Invest in domain-driven design, not hypothetical traffic.</li><li><strong>Ignoring Real-World Usage Patterns:</strong> Use analytics (e.g., New Relic, DataDog) to guide scaling decisions.</li><li><strong>Over-Architecting for Worst-Case:</strong> Plan for — and test — your actual worst spikes, not impossible “infinite users.”</li></ul><h3>🎯 Final Takeaway</h3><p>“Scalability” should be a measured, data-backed milestone, not a buzzword in your pitch deck. Focus on real traffic metrics, simple architectures, and graceful degradation. That way, when you truly outgrow your initial stack, you’ll have both the insights and the lean codebase to scale effectively — without years of wasted effort.</p><h3>🔮 Future Topics You Might Like</h3><ol><li><strong>Monoliths Aren’t Dead: Why You Should Start with One</strong></li><li><strong>Building a Load-Testing Pipeline: From JMeter to k6</strong></li><li><strong>What “Senior Engineer” Actually Means at a Startup</strong></li><li><strong>When to Choose SQL Over NoSQL (Hint: Most of the Time)</strong></li><li><strong>Monolith to Microservices: A Phased Extraction Strategy</strong></li><li><strong>Graceful Degradation Patterns for High-Traffic APIs</strong></li></ol><p>Happy engineering! 🛠️✨</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43a1d4392539" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Coding Tools for .NET Teams: Copilot vs. Tabnine vs. ChatGPT ]]></title>
            <link>https://medium.com/@movsesaleksanyan7/ai-coding-tools-for-net-teams-copilot-vs-tabnine-vs-chatgpt-6c00da83269e?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c00da83269e</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[tabnine]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[github-copilot]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Thu, 01 May 2025 07:47:12 GMT</pubDate>
            <atom:updated>2025-05-01T07:47:12.039Z</atom:updated>
            <content:encoded><![CDATA[<h3>AI Coding Tools for .NET Teams: Copilot vs. Tabnine vs. ChatGPT 🤖💻</h3><h3>🚀 Introduction</h3><p>In today’s fast-paced development world, .NET teams are under constant pressure to deliver high-quality code faster than ever. AI-powered coding assistants promise to boost productivity, reduce boilerplate, and even catch bugs early. But with so many options — GitHub Copilot, Tabnine, and ChatGPT — choosing the right tool can be daunting. In this article, we’ll break down how each performs in a .NET context, explore real-world use cases, and help you decide which fits your team’s workflow best.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-2M9kclu9LzhvjT-Ja0DtQ.png" /></figure><h3>🤖 GitHub Copilot</h3><p><strong>Integration &amp; Setup</strong></p><ul><li><strong>IDE Integration:</strong> Deeply embedded in Visual Studio and VS Code.</li><li><strong>Authentication:</strong> Uses GitHub OAuth; requires a paid Copilot license.</li></ul><p><strong>Pros</strong></p><ul><li>Context-aware suggestions based on your entire file.</li><li>Supports C#, F#, and Razor syntax seamlessly.</li><li>Learns from public and private repos (if enabled).</li></ul><p><strong>Cons</strong></p><ul><li><strong>Cost:</strong> $10/user/month (as of April 2025).</li><li><strong>Privacy:</strong> Sends code snippets to GitHub servers.</li><li><strong>Over-confidence:</strong> Occasionally suggests deprecated APIs.</li></ul><p><strong>Real-World Example</strong><br> A mid-sized fintech team integrated Copilot into their CI pipeline. Developers reported 25% fewer L1 review comments on API client code — Copilot handled repetitive DTO mappings automatically. <strong>(Opinion)</strong>: This made code reviews smoother but required vetting for edge-case null checks.</p><pre>// Copilot suggestion to parse JSON response<br>public async Task&lt;Order[]&gt; FetchOrdersAsync()<br>{<br>    using var client = new HttpClient();<br>    var json = await client.GetStringAsync(BaseUrl + &quot;/orders&quot;);<br>    return JsonSerializer.Deserialize&lt;Order[]&gt;(json);<br>}</pre><h3>🔍 Tabnine</h3><p><strong>Integration &amp; Setup</strong></p><ul><li><strong>IDE Plugins:</strong> Available for Visual Studio, Rider, VS Code.</li><li><strong>Deployment:</strong> Choose between Cloud or On-Premise (Enterprise plan).</li></ul><p><strong>Pros</strong></p><ul><li><strong>Privacy-First:</strong> On-prem model keeps code in-house.</li><li><strong>Speed:</strong> Local inference for near-instant suggestions.</li><li><strong>Customization:</strong> Train on your private codebase.</li></ul><p><strong>Cons</strong></p><ul><li><strong>Accuracy:</strong> May lag behind Copilot in code context understanding.</li><li><strong>Setup Complexity:</strong> On-prem requires GPU resources.</li><li><strong>Cost:</strong> Enterprise tier needed for private training.</li></ul><p><strong>Common Pitfall</strong><br> Over-customizing the model on a small codebase can lead to overfitting — suggestions that mirror your legacy patterns instead of best practices.</p><p><strong>Real-World Example</strong><br> Tech startup rolled out Tabnine On-Prem to comply with strict data policies. Though initial accuracy was 10% lower than Copilot’s, customizing on their domain-specific library improved suggestion relevance by 40% over three weeks.</p><h3>💬 ChatGPT</h3><p><strong>Integration &amp; Setup</strong></p><ul><li><strong>Workflow:</strong> Use the OpenAI API or chat.openai.com alongside your IDE.</li><li><strong>Flexibility:</strong> Prompt-driven; no IDE plugin (third-party extensions exist).</li></ul><p><strong>Pros</strong></p><ul><li><strong>Generative Power:</strong> Write entire methods, refactor blocks, or explain code.</li><li><strong>Language Agnostic:</strong> Equally fluent in C#, JavaScript, Python, and more.</li><li><strong>Free Tier &amp; Paid Plans:</strong> Flexible cost structure.</li></ul><p><strong>Cons</strong></p><ul><li><strong>Context Window:</strong> Limited to ~8 K tokens (needs careful prompt engineering).</li><li><strong>Manual Copy-Paste:</strong> Less seamless than IDE plugins.</li><li><strong>Latency:</strong> Round-trip chat can slow down flow.</li></ul><p><strong>Code Snippet Example</strong><br> <em>Request:</em> “Generate a .NET 7 minimal API endpoint for CRUD operations on a Product model.”<br> <em>Response from ChatGPT:</em></p><pre>var builder = WebApplication.CreateBuilder(args);<br>var app = builder.Build();<br><br>app.MapGet(&quot;/products&quot;, async (IProductRepository repo) =&gt;<br>    await repo.GetAllAsync());<br><br>app.MapGet(&quot;/products/{id}&quot;, async (int id, IProductRepository repo) =&gt;<br>    await repo.GetByIdAsync(id) is Product p ? Results.Ok(p) : Results.NotFound());<br><br>app.MapPost(&quot;/products&quot;, async (Product p, IProductRepository repo) =&gt;<br>{<br>    await repo.AddAsync(p);<br>    return Results.Created($&quot;/products/{p.Id}&quot;, p);<br>});<br><br>app.Run();</pre><p><strong>Use Case</strong><br> When migrating legacy Web API controllers to .NET 7 minimal APIs, ChatGPT helped generate boilerplate in seconds — saving ~2 hours on a 20-endpoint refactor.</p><h3>🔍 Quick Feature Comparison</h3><p><strong>IDE Integration</strong></p><ul><li><strong>GitHub Copilot:</strong> ✅ VS / VS Code / Rider</li><li><strong>Tabnine:</strong> ✅ VS / IDE-agnostic</li><li><strong>ChatGPT:</strong> ❌ via API or third-party extensions</li></ul><p><strong>Context Awareness</strong></p><ul><li><strong>GitHub Copilot:</strong> File-level</li><li><strong>Tabnine:</strong> File- &amp; Repo-level</li><li><strong>ChatGPT:</strong> Session-level (prompt based)</li></ul><p><strong>Privacy</strong></p><ul><li><strong>GitHub Copilot:</strong> Cloud-only</li><li><strong>Tabnine:</strong> Cloud &amp; On-Prem</li><li><strong>ChatGPT:</strong> Cloud-only</li></ul><p><strong>Generative Power</strong></p><ul><li><strong>GitHub Copilot:</strong> Medium</li><li><strong>Tabnine:</strong> Basic</li><li><strong>ChatGPT:</strong> High</li></ul><p><strong>Cost (per user)</strong></p><ul><li><strong>GitHub Copilot:</strong> ~$10/month</li><li><strong>Tabnine:</strong> Starts ~$39/month (Enterprise) Free tier + ~$9/month personal</li><li><strong>ChatGPT:</strong> Free tier + pay-as-you-go (~$20/month personal)</li></ul><h3>⚠️ Common Mistakes &amp; How to Avoid Them</h3><ul><li><strong>Blind Acceptance:</strong> Always review AI-suggested code for security and correctness.</li><li><strong>Neglecting Learning:</strong> Use suggestions as teaching moments, not crutches.</li><li><strong>Ignoring Feedback Loops:</strong> Regularly retrain/customize models (Tabnine) or refine prompts (ChatGPT).</li></ul><h3>🎯 Final Takeaway</h3><p>AI coding assistants can supercharge .NET development, but there’s no one-size-fits-all solution.</p><ul><li><strong>Choose Copilot</strong> if you want seamless IDE support and context-rich suggestions.</li><li><strong>Choose Tabnine</strong> for strict privacy requirements and on-prem deployments.</li><li><strong>Choose ChatGPT</strong> when you need broad generative power and multi-language flexibility.</li></ul><p>Align your choice with team size, budget, and security needs — and always keep a human in the loop! 👩‍💻👨‍💻</p><h3>🔮 Future Topics You Might Like</h3><ol><li><strong>Building a Custom .NET AI Assistant with OpenAI API</strong></li><li><strong>Securing AI-Generated Code in Production Environments</strong></li><li><strong>Benchmarking AI Assistant Accuracy on Complex Algorithms</strong></li></ol><p>Happy coding! ✨</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c00da83269e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI & Privacy in the Enterprise: What’s Safe to Delegate and Where Human Review Still Matters]]></title>
            <link>https://medium.com/@movsesaleksanyan7/ai-privacy-in-the-enterprise-whats-safe-to-delegate-and-where-human-review-still-matters-180ae6fab46f?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/180ae6fab46f</guid>
            <category><![CDATA[enterprise-technology]]></category>
            <category><![CDATA[privacy-by-design]]></category>
            <category><![CDATA[ai-in-enterprise]]></category>
            <category><![CDATA[ai-ethics]]></category>
            <category><![CDATA[secureai]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Tue, 15 Apr 2025 14:18:30 GMT</pubDate>
            <atom:updated>2025-04-15T14:18:30.688Z</atom:updated>
            <content:encoded><![CDATA[<p>AI tools are increasingly integrated into enterprise workflows — from code generation and chat-based assistance to decision support systems and anomaly detection. While these innovations offer major efficiency gains, they also raise serious questions about <strong>privacy, data governance, and accountability</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FLbiqHSd6vkrvZCuQNW5bQ.png" /></figure><p>In regulated industries like <strong>finance, healthcare, insurance, and government</strong>, it’s no longer a question of “Can we use AI?” but rather “<strong>Where can we safely apply AI — and where must humans remain in control?</strong>”</p><p>In this article, we’ll break down:</p><ul><li>What enterprise functions AI can safely support</li><li>Where it introduces risk</li><li>Privacy red flags to watch for</li><li>How to create an AI policy that protects sensitive systems</li></ul><h3>🧠 What AI Can Safely Handle in the Enterprise</h3><p>AI works best when used as an <strong>assistant</strong>, not a decision-maker. Here’s where it shines:</p><h3>✅ 1. Code Suggestions and Dev Productivity</h3><p>Tools like <strong>GitHub Copilot</strong>, <strong>Tabnine</strong>, and <strong>ChatGPT</strong> can autocomplete boilerplate, refactor code, or scaffold unit tests — <strong>without direct access to sensitive data</strong>.</p><p><strong>Safe when:</strong></p><ul><li>Used in isolated environments</li><li>Doesn’t access live production codebases</li><li>Output is reviewed and tested by developers</li></ul><h3>✅ 2. Log Analysis &amp; Error Detection</h3><p>AI excels at pattern recognition in log files, anomaly detection in metrics, and assisting with root cause analysis.</p><p><strong>Safe when:</strong></p><ul><li>Data is anonymized</li><li>Logs don’t contain PII</li><li>Human ops teams validate the AI’s conclusions</li></ul><h3>✅ 3. Drafting Documentation or Reports</h3><p>Language models can accelerate internal report generation, policy drafts, and technical documentation.</p><p><strong>Safe when:</strong></p><ul><li>Final output is reviewed by domain experts</li><li>It doesn’t auto-publish or make legal commitments</li></ul><h3>⚠️ Where AI Poses Risks</h3><p>These are the areas where <strong>human oversight is mandatory</strong> or where AI should be completely excluded:</p><h3>❌ 1. Handling Sensitive or Regulated Data</h3><p>Examples: Patient records, financial transactions, legal documents, HR data</p><p><strong>Why it’s risky:</strong></p><ul><li>Data may be sent to external servers (e.g., OpenAI APIs)</li><li>Lack of audit trail</li><li>Potential for data leakage or compliance violations (GDPR, HIPAA, PCI-DSS)</li></ul><h3>❌ 2. Automated Decision-Making That Impacts People</h3><p>Examples: Loan approvals, hiring decisions, policy enforcement, fraud detection</p><p><strong>Why it’s risky:</strong></p><ul><li>Bias in training data can lead to discrimination</li><li>Lack of transparency (black-box outputs)</li><li>Accountability gaps (who’s responsible?)</li></ul><h3>❌ 3. Security Configurations or Identity Management</h3><p>Letting AI generate access policies, secrets, or IAM rules can lead to dangerous misconfigurations.</p><h3>🔐 Key Privacy Concerns in AI Usage</h3><ol><li><strong>Data Residency</strong>: Where is your data going? Many cloud AI tools send prompts to US/EU-based servers.</li><li><strong>Prompt Injection &amp; Leakage</strong>: Inputs to AI systems can be manipulated to expose prior context or proprietary information.</li><li><strong>Model Training Contamination</strong>: With third-party APIs, even anonymized inputs may be stored and used to fine-tune future models (unless explicitly opted out).</li><li><strong>No Right to be Forgotten</strong>: Unlike databases, models can’t easily “delete” learned information once trained.</li><li><strong>Logging Hidden Risks</strong>: Code snippets or internal logic pasted into ChatGPT may inadvertently contain credentials or business rules.</li></ol><h3>🧩 Building a Safe AI Usage Policy</h3><p>To use AI responsibly in the enterprise, establish guardrails:</p><h3>✅ Internal Guidelines Should Cover:</h3><ul><li><strong>Which tools are approved</strong> (e.g., Copilot, Tabnine On-Prem, Azure OpenAI)</li><li><strong>What data can be shared</strong> (no client identifiers, secrets, contracts)</li><li><strong>What functions are assistive vs. autonomous</strong></li><li><strong>Who owns the review responsibility</strong></li><li><strong>When and how to redact or anonymize data</strong></li></ul><h3>🛡️ Best Practices:</h3><ul><li>Use <strong>on-prem AI solutions</strong> or private LLMs where possible</li><li>Mask or transform sensitive input before using AI</li><li>Require <strong>human-in-the-loop</strong> for all AI outputs in production</li><li>Enable <strong>logging and audit trails</strong> for all AI-assisted actions</li><li>Educate teams on <strong>ethical use and security risks</strong></li></ul><h3>🧠 Real-World Examples</h3><ul><li><strong>Samsung</strong> reportedly banned ChatGPT internally after employees pasted source code and confidential notes into the chat. (<a href="https://www.forbes.com/sites/siladityaray/2023/05/02/samsung-bans-chatgpt-and-other-chatbots-for-employees-after-sensitive-code-leak">Source</a>)</li><li><strong>Apple, JPMorgan, and Amazon</strong> have restricted AI tools internally for similar privacy and IP leakage concerns. (<a href="https://www.wsj.com/tech/apple-restricts-use-of-chatgpt-joining-other-companies-wary-of-leaks-d44d7d34">Source</a>)</li><li><strong>Tabnine</strong>, unlike Copilot, offers <strong>self-hosted models</strong>, which are preferred in highly regulated environments.</li></ul><h3>❗ Real-World AI Mistakes You Can’t Ignore</h3><p>Even state-of-the-art AI tools make mistakes — and in enterprise settings, those mistakes can be costly or even dangerous.</p><h3>🤖 Common AI Errors</h3><ul><li><strong>Hallucinations</strong>: AI generates false information that sounds accurate (e.g., citing non-existent APIs, wrong method names, or fake legal policies).</li><li><strong>Overconfident Wrong Answers</strong>: AI tools often present incorrect suggestions in a confident tone, which can mislead developers or analysts.</li><li><strong>Incomplete Code Snippets</strong>: Auto-generated logic may miss null checks, edge cases, or security validations.</li><li><strong>Bias Amplification</strong>: Models trained on historical or public data can inherit and reinforce biases (racial, gender, geographic, etc.).</li></ul><h3>🧨 Notable Real-World AI Failures</h3><ul><li><strong>GitHub Copilot Security Study</strong>: A research paper from NYU found that <strong>over 40% of Copilot’s code suggestions contained security vulnerabilities</strong>, such as hardcoded credentials or unsafe SQL. (<a href="https://arxiv.org/abs/2108.09293">Source</a>)</li><li><strong>ChatGPT Generates Fake Citations</strong>: Multiple lawyers in the US were fined after submitting court documents with <strong>AI-generated, non-existent legal precedents</strong>. The tool hallucinated cases that sounded real but didn’t exist. (<a href="https://www.cnn.com/2023/05/27/business/chat-gpt-avianca-mata-lawyers/index.html">CNN</a>)</li><li><strong>Financial Reporting Risks</strong>: A global accounting firm flagged errors in AI-generated financial summaries that misrepresented client KPIs due to subtle miscalculations and rounding errors.</li><li><strong>AI-Generated IAM Policies</strong>: An enterprise reported a misconfigured access policy created via AI suggestions that granted <strong>over-permissive access to internal services</strong>, triggering a full audit.</li></ul><h3>🧠 Bottom Line</h3><p>AI doesn’t know your domain. It doesn’t know your policies, your risk appetite, or your compliance obligations.</p><p>That’s why <strong>review, testing, and human validation</strong> remain non-negotiable — especially when dealing with production systems, user data, or security-sensitive logic.</p><h3>🔍 Final Takeaway</h3><p>AI is here to stay — but <strong>blind trust is not a strategy</strong>. In the enterprise, your <strong>AI adoption must be intentional, transparent, and controlled</strong>.</p><p>✅ Use AI to boost speed, creativity, and efficiency.<br> 🚫 Never let it handle decisions, secrets, or sensitive data without a human in the loop.</p><h3>📢 Coming Soon</h3><ul><li>✨ <em>AI Coding Tools for .NET Teams: Copilot vs. Tabnine vs. ChatGPT</em></li><li>🔐 <em>How to Implement Privacy-First Design in AI-Driven Apps</em></li><li>⚙️ <em>Deploying Your Own LLMs in Enterprise Environments</em></li><li>💬 <em>Building AI Chatbots with Guardrails in .NET and Supabase</em></li></ul><p>👉 <strong>Follow me here on </strong><a href="https://medium.com/@movsesaleksanyan7"><strong>Medium</strong> </a>for deep dives into .NET architecture, applied AI, and enterprise-grade tech strategies.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=180ae6fab46f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Low-Code is Revolutionizing .NET Development for Enterprises]]></title>
            <link>https://medium.com/@movsesaleksanyan7/how-low-code-is-revolutionizing-net-development-for-enterprises-d9dbb231a4ad?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9dbb231a4ad</guid>
            <category><![CDATA[lowcode-development]]></category>
            <category><![CDATA[powerplatform]]></category>
            <category><![CDATA[enterprise-software]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Sat, 12 Apr 2025 09:26:52 GMT</pubDate>
            <atom:updated>2025-04-12T09:26:52.173Z</atom:updated>
            <content:encoded><![CDATA[<h3>How Low-Code is Revolutionizing .NET Development for Enterprises</h3><p><strong>A Case Study on Low-Code Adoption in Enterprise .NET Projects</strong></p><p>In a <a href="https://medium.com/@movsesaleksanyan7/low-code-vs-traditional-net-development-pros-and-cons-in-2025-3d686a4b4a5c">previous article</a>, we compared <strong>low-code vs. traditional .NET development</strong>, weighing the strengths and limitations of both approaches. Now, let’s explore how <strong>low-code is being successfully adopted within enterprise .NET ecosystems</strong> — not as a replacement, but as a catalyst for agility, speed, and strategic delivery.</p><p>This case-study-style breakdown demonstrates how enterprises are integrating low-code into their .NET stack to solve real business challenges.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pyqTHaolhe2rC5Is-giK0g.png" /></figure><h3>🚀 The Enterprise Challenge</h3><p>A mid-size financial services company faced growing pressure to deliver internal tools for operations, compliance, and customer service. Their core systems were built with <strong>ASP.NET Core and SQL Server</strong>, supported by a traditional dev team.</p><p><strong>The blockers:</strong></p><ul><li>Long delivery cycles for internal apps</li><li>Constant backlog of feature requests from non-technical departments</li><li>Lack of developer resources for low-priority but high-impact internal tools</li><li>Increasing demand for automation and self-service solutions</li></ul><h3>🧩 Enter Low-Code: The Hybrid Strategy</h3><p>Instead of overloading their engineering team, they introduced <strong>Power Apps</strong> (a low-code Microsoft platform) to build operational tools — integrated seamlessly with their existing <strong>.NET APIs</strong> and <strong>Azure infrastructure</strong>.</p><p><strong>What stayed in traditional .NET:</strong></p><ul><li>Core business logic</li><li>Public-facing services</li><li>API integrations with third-party providers</li><li>Authentication and authorization logic</li></ul><p><strong>What shifted to low-code:</strong></p><ul><li>Admin portals</li><li>Approval workflows</li><li>Data collection forms</li><li>Internal dashboards and reporting tools</li></ul><h3>🔗 Architecture in Practice</h3><ul><li><strong>Backend Services</strong>: ASP.NET Core with REST/gRPC APIs</li><li><strong>Low-Code Frontends</strong>: Power Apps consuming APIs directly</li><li><strong>Authentication</strong>: Azure AD SSO across both platforms</li><li><strong>Data Layer</strong>: Dataverse + SQL Server via connectors</li><li><strong>Business Logic Control</strong>: Core workflows stay in .NET</li></ul><h3>⚙️ Results After 6 Months</h3><ul><li>🚀 <strong>65% reduction</strong> in dev time for internal tools</li><li>🧠 Non-dev teams able to prototype and ship on their own</li><li>🎯 Core .NET developers freed up for critical feature work</li><li>🧾 Significant drop in internal support tickets</li><li>🔄 Smooth interoperability between Power Platform and .NET APIs</li></ul><h3>🔍 Lessons Learned</h3><ul><li><strong>Governance is essential</strong>: Define clear boundaries for low-code use.</li><li><strong>Versioned APIs empower scalability</strong> across frontend platforms.</li><li><strong>Low-code ≠ no-code</strong>: Still requires engineering discipline (testing, versioning, lifecycle).</li><li><strong>Dev involvement matters</strong>: Core systems must remain under experienced hands.</li></ul><h3>🌐 When Low-Code Works in the .NET World</h3><h3>✅ Ideal Scenarios:</h3><ul><li>Internal tools, dashboards, approval workflows</li><li>Teams already using Microsoft 365 / Azure</li><li>Projects with short timelines and fast iteration needs</li></ul><h3>🚫 Less Ideal For:</h3><ul><li>High-performance public platforms</li><li>Deeply customized UIs</li><li>Complex multi-service orchestration flows</li></ul><h3>🧠 Final Takeaway</h3><p>Low-code isn’t a shortcut — it’s a <strong>strategic enabler</strong>. When used in the right places, it accelerates delivery, empowers non-dev contributors, and reduces strain on core engineering resources.</p><p>Instead of replacing traditional .NET development, <strong>low-code complements it</strong>, forming a hybrid strategy that allows enterprises to scale both speed and control.</p><h3>👀 What’s Next?</h3><p>If you found this helpful, stay tuned — upcoming articles will dive deeper into:</p><ul><li>🤖 <strong>AI-Powered Coding Tools</strong>: Copilot, Tabnine, and how AI is changing development (and what it still can’t do in enterprise systems)</li><li>🔐 <strong>AI &amp; Privacy in the Enterprise</strong>: What’s safe to delegate to AI, and where human review still matters</li><li>⏳ <strong>Workflow Orchestration with Temporal</strong>: Building dynamic approval and task pipelines in enterprise apps</li><li>📦 <strong>Supabase for .NET Developers</strong>: Using serverless Postgres + auth in modern applications</li><li>🧱 <strong>Modular Architecture in .NET</strong>: Designing scalable, maintainable systems using domain-driven design</li></ul><p>👉 <a href="https://medium.com/@movsesaleksanyan7"><strong>Follow me</strong></a> here on Medium to get practical, architecture-first .NET insights — always rooted in real-world experience.</p><h3>📚 References &amp; Real-World Case Studies</h3><p>The outcomes shared in this article are backed by real enterprise experiences. For deeper insights and validation, explore the following case studies and research:</p><ul><li><a href="https://info.microsoft.com/rs/157-GQE-382/images/EN-US-CNTNT-report-The-Total-Economic-Impact-of-Microsoft-Dynamics-365-for-Field-Service.pdf">The Total Economic Impact™ of Microsoft Power Platform — Forrester</a></li><li><a href="https://www.microsoft.com/en-us/power-platform/blog/power-apps/hmgroup/">How H&amp;M Group Empowers Citizen Developers with Power Apps</a></li><li><a href="https://www.microsoft.com/en-us/power-platform/blog/power-apps/meet-the-developers-combining-power-platform-and-azure-to-go-faster/">Blackmores: Unifying Systems with Power Platform + Azure</a></li><li><a href="https://www.microsoft.com/en-us/power-platform/blog/power-apps/custom-air-products-services-manages-hvac-manufacturing-process-using-the-power-platform/">Custom Air Products: Low-Code for Manufacturing Process Efficiency</a></li><li><a href="https://partner.microsoft.com/sv-se/case-studies/cognizant2">Cognizant: Scaling Enterprise Solutions with Power Platform</a></li></ul><p>These examples highlight the measurable impact of low-code adoption within .NET-centric enterprises.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9dbb231a4ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Low-Code vs. Traditional .NET Development: Pros and Cons in 2025]]></title>
            <link>https://medium.com/@movsesaleksanyan7/low-code-vs-traditional-net-development-pros-and-cons-in-2025-3d686a4b4a5c?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d686a4b4a5c</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[app-development]]></category>
            <category><![CDATA[low-code]]></category>
            <category><![CDATA[tech-trends-2025]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Sun, 06 Apr 2025 08:17:20 GMT</pubDate>
            <atom:updated>2025-04-06T08:17:20.514Z</atom:updated>
            <content:encoded><![CDATA[<h3>Low-Code vs. Traditional .NET Development: Pros and Cons in 2025</h3><p>As the demand for faster delivery cycles and cost-effective development rises, the debate between <strong>low-code platforms</strong> and <strong>traditional .NET development</strong> has intensified — especially in 2025, with mature tools available for both. While low-code accelerates time-to-market and empowers non-developers, traditional development remains the gold standard for flexibility, performance, and long-term control.</p><p>This article compares both approaches within the .NET ecosystem, helping you decide when and where to apply each.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Na5gBo-ia8p-ghXbEAJxEw.png" /></figure><h3>What Is Low-Code Development?</h3><p>Low-code development uses visual interfaces, pre-built templates, and declarative tools to build apps with minimal hand-written code. Microsoft’s <a href="https://powerplatform.microsoft.com/">Power Platform</a>, including <strong>Power Apps</strong>, is a prime example tailored for business users and developers alike.</p><h3>What Is Traditional .NET Development?</h3><p>This refers to building apps using C#, ASP.NET Core, EF Core, Blazor, and related technologies, typically with custom code, full control over architecture, and professional developer workflows (e.g., CI/CD, testing, source control).</p><h3>📊 Use Cases: When to Use Each</h3><p><strong>•Rapid internal tools</strong> → ✅ <strong>Low-Code</strong><br> <strong>• Complex business rules</strong> → ✅ <strong>Traditional .NET</strong><br> <strong>• Highly customized UI/UX</strong> → ✅ <strong>Traditional .NET</strong><br> <strong>• Prototyping with quick iteration</strong> → ✅ <strong>Low-Code</strong><br> <strong>• Multi-layered API integrations</strong> → ✅ <strong>Traditional .NET</strong><br> <strong>• Citizen developer empowerment</strong> → ✅ <strong>Low-Code</strong><br> <strong>• Cross-platform public apps</strong> → ✅ <strong>Traditional .NET</strong></p><h3>Pros and Cons</h3><h4>🧩 Low-Code (.NET via Power Platform or OutSystems)</h4><p><strong>Pros:</strong></p><ol><li><strong>Faster delivery:</strong> Build MVPs in days instead of weeks.</li><li><strong>Lower skill barrier:</strong> Enables business analysts or junior devs to contribute.</li><li><strong>Integrated with Microsoft stack:</strong> Easy access to Office 365, Dataverse, Teams, etc.</li><li><strong>Built-in hosting and deployment:</strong> No infrastructure worries.</li></ol><p><strong>Cons:</strong></p><ol><li><strong>Limited customization:</strong> Not suitable for edge-case requirements or advanced logic.</li><li><strong>Vendor lock-in risk:</strong> Dependent on platform-specific features and pricing.</li><li><strong>Performance bottlenecks:</strong> Less control over optimization.</li><li><strong>Scalability concerns:</strong> Harder to scale complex systems or APIs efficiently.</li></ol><h4>🔧 Traditional .NET Development</h4><p><strong>Pros:</strong></p><ol><li><strong>Maximum control:</strong> Architecture, performance, UI, and security fully customizable.</li><li><strong>Scalable and testable:</strong> Better suited for enterprise-grade apps and APIs.</li><li><strong>Rich ecosystem:</strong> NuGet, libraries, frameworks, and cross-platform tooling.</li><li><strong>Long-term maintainability:</strong> Easier to refactor, audit, and extend.</li></ol><p><strong>Cons:</strong></p><ol><li><strong>Longer development time:</strong> Custom features take time to build.</li><li><strong>Higher skill requirement:</strong> Needs experienced developers and a solid dev process.</li><li><strong>Infrastructure responsibility:</strong> DevOps, hosting, and monitoring fall on the team.</li></ol><h3>2025 Trends: Where Things Are Heading</h3><ul><li><strong>Hybrid adoption is rising</strong>: Enterprises use low-code for prototyping or internal tools, but rely on traditional .NET for core systems.</li><li><strong>Fusion teams</strong>: Developers + business users work together, leveraging both platforms.</li><li><strong>Blazor + Power Platform bridges</strong>: In 2025, you can embed Blazor components inside Power Apps for advanced use cases.</li></ul><h3>Conclusion</h3><p>Both low-code and traditional .NET development have matured significantly by 2025. Rather than choosing one over the other, smart teams are embracing <strong>hybrid strategies</strong> — using low-code for speed where possible, and falling back to traditional .NET when precision and scalability are critical.</p><p>Evaluate based on <strong>project complexity, team composition, time constraints, and long-term goals</strong>. The best solution often involves <strong>leveraging the strengths of both</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d686a4b4a5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why You Should Prefer the Result Pattern Over Exceptions in C#]]></title>
            <link>https://medium.com/@movsesaleksanyan7/why-you-should-prefer-the-result-pattern-over-exceptions-in-c-ff9607b74ed7?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff9607b74ed7</guid>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[exception-handling]]></category>
            <category><![CDATA[result-pattern]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Fri, 04 Apr 2025 05:57:59 GMT</pubDate>
            <atom:updated>2025-04-04T05:57:59.601Z</atom:updated>
            <content:encoded><![CDATA[<p>Exception handling has long been the default approach to dealing with errors in C#. However, in recent years, the Result pattern has emerged as a cleaner, safer, and more maintainable alternative. This article explores why and how you should integrate the Result pattern into your ASP.NET Core applications using libraries like ErrorOr, compares it with traditional exception handling, and discusses improvements with exceptions in .NET 9.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tRNJv7JT-uvi9uQM9o8fRA.png" /></figure><h3>Understanding the Result Pattern</h3><p>The Result pattern explicitly returns either a success result or a structured error without interrupting the program flow through exceptions. It’s essentially a wrapper that clearly communicates outcomes to callers.</p><h3>A Basic Result Structure with ErrorOr</h3><p><a href="https://github.com/amantinband/error-or">ErrorOr</a> is a popular implementation of the Result pattern in .NET, providing structured errors and fluent syntax.</p><pre>public ErrorOr&lt;User&gt; CreateUser(string username, string email)<br>{<br>    if (string.IsNullOrEmpty(username))<br>        return Error.Validation(&quot;Username.Empty&quot;, &quot;Username cannot be empty.&quot;);<br><br>    if (!email.Contains(&quot;@&quot;))<br>        return Error.Validation(&quot;Email.InvalidFormat&quot;, &quot;Invalid email format.&quot;);<br><br>    if (UserExists(username))<br>        return Error.Conflict(&quot;User.Duplicate&quot;, &quot;User already exists.&quot;);<br><br>    var user = new User(username, email);<br>    return user;<br>}</pre><h3>Traditional Exception Handling vs Result Pattern</h3><p>Let’s compare traditional exception-based handling with the Result pattern approach clearly:</p><h3>Traditional Exception-Based Approach</h3><pre>public User CreateUser(string username, string email)<br>{<br>    if (string.IsNullOrEmpty(username))<br>        throw new ArgumentException(&quot;Username cannot be empty.&quot;);<br><br>    if (!email.Contains(&quot;@&quot;))<br>        throw new ArgumentException(&quot;Invalid email format.&quot;);<br><br>    if (UserExists(username))<br>        throw new InvalidOperationException(&quot;User already exists.&quot;);<br><br>    return new User(username, email);<br>}<br><br>// API Controller example<br>[HttpPost(&quot;users&quot;)]<br>public IActionResult CreateUser(CreateUserRequest request)<br>{<br>    try<br>    {<br>        var user = CreateUser(request.Username, request.Email);<br>        return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);<br>    }<br>    catch (Exception ex)<br>    {<br>        return BadRequest(new { error = ex.Message });<br>    }<br>}</pre><h3>Result Pattern Approach</h3><pre>[HttpPost(&quot;users&quot;)]<br>public IActionResult CreateUser(CreateUserRequest request)<br>{<br>    var result = _userService.CreateUser(request.Username, request.Email);<br><br>    return result.Match(<br>        user =&gt; CreatedAtAction(nameof(GetUser), new { id = user.Id }, user),<br>        errors =&gt; Problem(errors));<br>}</pre><h3>Why the Result Pattern Is Better Than Exceptions</h3><h3>Pros:</h3><ol><li><strong>Explicit Error Handling:</strong> Clearly communicates possible outcomes.</li><li><strong>Improved Readability:</strong> Reduces deeply nested try-catch blocks.</li><li><strong>Performance:</strong> Avoids expensive stack unwinding from exceptions.</li><li><strong>Simplified Testing:</strong> Easier validation of success/failure scenarios.</li></ol><h3>Cons:</h3><ol><li><strong>Increased Boilerplate:</strong> Slightly more verbose than throwing exceptions.</li><li><strong>Learning Curve:</strong> Requires developers to adapt their existing error-handling strategies.</li></ol><h3>Improvements with Exceptions in .NET 9</h3><p>.NET 9 significantly improves the performance of exceptions, making them faster and less resource-intensive. This enhancement reduces the overhead traditionally associated with exception handling, making exceptions a more viable choice in performance-critical scenarios.</p><p>However, even with these improvements, the Result pattern remains valuable due to its explicitness and maintainability.</p><h3>Conclusion</h3><p>While .NET 9 improves exception handling performance, the Result pattern (and libraries like ErrorOr) continues to offer clear advantages in explicitness, maintainability, readability, and structured error handling. Adopting this approach in your ASP.NET Core applications can greatly enhance your code quality and developer productivity.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff9607b74ed7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Netflix Tech Evolution: Streaming into the Future]]></title>
            <link>https://medium.com/@movsesaleksanyan7/netflix-tech-evolution-streaming-into-the-future-2dca27457654?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/2dca27457654</guid>
            <category><![CDATA[temporalio]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[netflix]]></category>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Sun, 06 Oct 2024 08:37:06 GMT</pubDate>
            <atom:updated>2024-10-06T08:37:06.650Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine this: Friday night, couch, binge-watching your favorite show. You click it on, and voilà-you are taken into a high-resolution world of streaming content. Magic? Not quite. But behind that seamless experience, a complex maze of technology-one that would make even the most seasoned tech enthusiast drool-is hidden.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HgPzKlLrCM9LOz4Y_hKKUg.jpeg" /></figure><p>Now, let me walk you through Netflix’s technical evolution: a story of innovation, overcoming hurdles, and some really awesome technology.</p><p><strong>The Early Days: Monoliths and Growing Pains</strong></p><p>By convention, Netflix ran a monolithic architecture. Now, imagine serving millions of users on one big application. Yikes! As the number of users grew, so did the challenges. More frequent outages and increasingly more of a nightmare to scale-a something had to give.</p><p>Along Came the Cloud: Game-Changer</p><p>Full steam ahead, Netflix dove head-first into the cloud, placing all of its infrastructure onto Amazon Web Services. What was to become one small step proved, in reality, one giant leap that prepared them for future innovations.</p><p>It wasn’t just a move to the cloud; it was a whole rethink of their architecture. Netflix got “cloud-native” before that was cool. They embraced services which AWS put on offer, including compute through EC2, storage on S3, and content delivery through CloudFront. But they didn’t stop there.</p><p><strong>Microservices: Break It Down</strong></p><p>Well, Netflix didn’t stop there. They literally just tore their monolith apart into hundreds of microservices. Every little bit of functionality would become its own service. This opens up all sorts of flexibility and scalability never thought possible: try improving that recommendation algorithm without touching the other services.</p><p>The key principles this microservices architecture is based on include:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*xoE8GKdxQPb_Zl6hfhjMvg.jpeg" /></figure><p>1. <strong>Single Responsibility</strong>: One thing is done by each service, and it does it well.<br>2. <strong>Loose Coupling</strong>: Services can be updated independently without cascading effects into others.<br>3. <strong>Continuous Delivery</strong>: Small, frequent releases rather than huge, dangerous deployments.</p><p><strong>The Secret Sauce: Netflix OSS</strong></p><p>That is when it gets even more interesting. Netflix didn’t keep that technological advancement to themselves alone; a lot of that was cast out there by open-sourcing their tools and created something called the Netflix Open Source Software Center, Netflix OSS. Talk about paying back to the community!</p><p>Some of their pioneering tools include:</p><p>1. <strong>Hystrix</strong>: A library that controls the interaction between distributed services to improve latency and fault tolerance.</p><p>2. <strong>Eureka</strong>: Resilient mid-tier load balancing and failover for service registration.</p><p>3. <strong>Zuul</strong>: Gateway services provide dynamic routing, monitoring, resiliency, and security.</p><p>4. <strong>Ribbon</strong>: IPC cloud library with software load balancers.</p><p>5. <strong>Conductor</strong>: Microservices orchestration engine.</p><p><strong>Temporal.io: Orchestrating the Chaos</strong></p><p>But probably the most interesting recent addition in Netflix’s tech stack is Temporal.io: an open-source microservice orchestration platform that changes the game in terms of how people build and operate resilient applications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*obPNx9n_L6HLdToZYuDAGQ.png" /></figure><p>So far, Temporal has enabled Netflix to create applications that can be fault-tolerant and long-running in nature. Think of a complex workflow orchestrated across many services where failures are handled graciously and operations can start off from where they have left off. That is the power of Temporal.</p><p>How does this work? At the heart of Temporal provides:</p><p>1. <strong>Workflow Engine</strong>: Records the sequence of activities inside a business process.<br>2. <strong>Task Queue</strong>: Routes activities into workers.<br>3. <strong>Worker Service</strong>: Executes the tasks.<br>4. <strong>Web UI</strong>: Lists active workflows.</p><p><strong>The Data Backbone: Apache Kafka</strong></p><p>Behind the scenes, Apache Kafka is deployed at scale into the Netflix data pipeline. This acts as the central nervous system for its data infrastructure to handle the following:</p><p>1. <strong>Real-time Data Streams</strong>: User interactions, history of viewing, system logs.<br>2. <strong>Event-Driven Architecture</strong>: This allows for real-time action of services to anything that may be taking place on the outside.<br>3. <strong>Data Integration</strong>: This allows for integration between variety data sources and sinks.</p><p>Netflix deals in really huge amounts of data-small petabytes a day, compacted. Kafka being distributed and of high throughput enables dealing with this tsunami of information.</p><p><strong>Metaflow: Machine Learning at Scale</strong></p><p>The Netflix recommendation system is the stuff of legend, but do you know how they manage all those machine learning models? Enter Metaflow, an internally created ML platform that later got open-sourced.</p><p>With Metaflow, data scientists will be empowered to:</p><ol><li><strong>Train Models</strong>: Write Python code that easily goes from local development to production.<br>2. <strong>Prepare Data</strong>: Ingest and process large datasets with ease.<br>3. <strong>Schedule Jobs</strong>: Model training and deployment automated.<br>4. <strong>Monitor Performance</strong>: Model performance can be monitored in real time.</li></ol><p><strong>Spinnaker: Continuous Delivery on Steroids</strong><br>Perhaps a key feature of microservices-or perhaps a corollary to it-was the requirement of deploying code often and safely. A software addressing this challenge for Netflix was Spinnaker, an open-source, multi-cloud continuous delivery platform.<br>Spinnaker makes possible:</p><p>1. <strong>Automated Pipelines</strong>: One can build complex deployment workflows.<br>2. <strong>Multi-Cloud Deployments</strong>: A user can deploy on AWS, Google Cloud, Azure, and more.<br>3. <strong>Canary Releases</strong>: It’s able to gradually roll out changes to a small percentage of users.<br>4. <strong>One-Click Rollbacks</strong>: If something goes wrong, it will revert quickly to the previous version.</p><p><strong>Challenges Ahead</strong></p><p>However, let us get real-the streaming wars are heating up, and Netflix is in for some serious challenges:</p><p>1. <strong>Content Delivery</strong>: It is used by millions of users for the simultaneous viewing of shows, movies, and documentaries, and its delivery has remained a constant fight over varied devices and network conditions. Netflix combines the deployment of its own Open Connect appliances with third-party CDNs in order to bring the content closer to the user.</p><p>2. <strong>Personalization at Scale</strong>: The Netflix recommendation system is the stuff of legend, but to keep it accurate and relevant to hundreds of millions of users in all corners of the globe is no mean feat. Constantly trying new algorithms — Deep Learning models included — in the hope of making better suggestions.</p><p>3. <strong>Global Expansion</strong>: With every new market they tried to enter, came new technical issues from the speed of the Internet right to what kind of content needs to be used. It’s all different in each target market. Netflix wants to fine-tune streaming technology against conditions from low to high.</p><p>4. <strong>Innovation Race</strong>: It is a competition like Disney+ and Amazon Prime hot on its heels, and that demands Netflix seeks more and more. Interactive content-remember Bandersnatch? And claims to gaming too.</p><p>5. <strong>Content Protection</strong>: As a content provider and distributor, Netflix needs to strike the correct balance between ease of access and strong DRM. That is saying for both proprietary and industry-standard technologies, combined in an effort to safeguard their content.</p><p><strong>The Future is Streaming</strong></p><p>Moving on, Netflix is going deep into a few bleeding-edge technologies:</p><p>1. <strong>AV1 Codec</strong>: Netflix has been one of the main contributors to this royalty-free and open video coding format touted as offering better compression efficiency.</p><p>2. <strong>WebAssembly</strong>: They are trying WASM for pushing more compute-intensive applications toward new ways of interaction in the browser.</p><p>3. <strong>Edge Computing</strong>: Netflix does more processing on the edge of the network, which has helped bring down latency and offer a better experience for the user.</p><p>4. <strong>Adaptive Streaming</strong>: The steaming quality adaptively changes concerning the network condition and continuously they refine this technology.</p><p>As I close this post, the sense of wonder with which Netflix as a technical marvel-from such an insipidly plain, simple DVD rental service to a global streaming juggernaut-has therefore struck me; if there is one story that needs to be told about the power of innovation and bold technical decisions, it needs to be this one.</p><p>But next time you’re settling in for that Netflix binge, remember to marvel at all the invisible tech magic going on behind the scenes. It’s not just streaming video; it’s really pushing the envelope on what will be possible in technology.</p><p>But one question-what’s next by Netflix? The only thing that is sure, I’m gonna watch it-both as a user and a techie. The future of streaming indeed looks bright with Netflix leading the torch upfront, high, lighting the way with its dazzling array of technologies.</p><p>So, go ahead and pop the popcorn, get cozy. The show is about to start, but not a new season of “Stranger Things.” The real blockbuster is back-of-screen technology-literally-always changing, never stopping in its innovation. Now that’s something worth binge-watching!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2dca27457654" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comparing Riok Mapperly and AutoMapper: A Performance Analysis for .NET Object Mapping]]></title>
            <link>https://medium.com/@movsesaleksanyan7/comparing-riok-mapperly-and-automapper-a-performance-analysis-for-net-object-mapping-a4620eedf8f8?source=rss-7b012040e1e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4620eedf8f8</guid>
            <dc:creator><![CDATA[Movses Aleksanyan]]></dc:creator>
            <pubDate>Mon, 03 Apr 2023 11:15:53 GMT</pubDate>
            <atom:updated>2023-04-03T11:17:35.508Z</atom:updated>
            <content:encoded><![CDATA[<h3>Comparing Riok Mapperly and AutoMapper: A Performance Analysis for .NET Object Mapping</h3><p>If you are looking for a .NET source generator for generating object mappings, you might be interested in comparing <strong>Mapperly </strong>and <strong>AutoMapper</strong>, two popular libraries that can help you with this task. In this blog post, we will briefly introduce these libraries and share some tips and tricks for improving their performance.</p><p><strong>Mapperly</strong> is a library inspired by MapStruct that creates the mapping code at build time, eliminating the runtime overhead and allowing you to verify the generated code easily. You can define your mappers as partial classes with the `Mapper` attribute and use the `Map` method to perform the mapping. Mapperly supports custom mapping methods, value resolvers, null checks, nested mappings, and more. You can find more information and documentation on its GitHub page.</p><p><strong>AutoMapper</strong> is a library that simplifies the mapping between objects by using a convention-based approach. You can configure your mappings using the `CreateMap` method and use the `Map` method to perform the mapping. AutoMapper supports projection, flattening, reverse mapping, custom converters, conditional mapping, and more. You can find more information and documentation on its website.</p><p>Here are some tips and tricks for improving the performance of these libraries:</p><p>- For Mapperly, you can use the `MapperConfiguration` class to configure your mappings in a centralized way and avoid repeating code. You can also use the `MapperConfigurationExpression` class to customize the configuration options such as naming conventions, null handling, etc.<br>- For AutoMapper, you can use the `Mapper.Initialize` method to initialize your mappings once in your application startup and avoid creating multiple mapper instances. You can also use the `Mapper.Configuration.CompileMappings` method to compile your mappings ahead of time and reduce the first map time.<br>- For both libraries, you can use benchmarks and profiling tools to measure and optimize the performance of your mappings. You can also compare the generated code and see how they differ in terms of complexity and efficiency.</p><p>But how do these libraries perform in terms of speed and memory usage? Let’s find out!</p><p>I created a simple console application that uses both Riok Mapperly and AutoMapper to map 100,000 objects from a source class to a destination class. The source class has 10 properties of different types, and the destination class has the same properties plus one extra. I used BenchmarkDotNet to measure the execution time and memory allocation of each library. Here are the results:</p><p><em>| Library | Mean Time | Allocated Memory |<br>| — — — — -| — — — — — -| — — — — — — — — — |<br>| Riok Mapperly | 28.6 ms | 3.9 MB |<br>| AutoMapper | 36.4 ms | 4.8 MB |</em></p><p>As you can see, Riok Mapperly is faster and more memory-efficient than AutoMapper. It takes about 22% less time and 19% less memory to map the same number of objects. This is because Riok Mapperly uses expression trees and dynamic methods to generate the mapping code at runtime, while AutoMapper uses reflection and delegates. Expression trees and dynamic methods are more optimized by the JIT compiler and have less overhead than reflection and delegates.</p><p>So, if you are looking for a fast and lightweight object mapping library for .NET, you should definitely check out Riok Mapperly. It has a simple and fluent API that is similar to AutoMapper, but with better performance and less memory consumption. You can find more information and examples on their website: <a href="https://mapperly.riok.app/">https://mapperly.riok.app</a></p><p>Thanks for reading and happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4620eedf8f8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>