<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: rahul bandal</title>
    <description>The latest articles on DEV Community by rahul bandal (@rahul_bandal_afe623cbf2e2).</description>
    <link>https://dev.to/rahul_bandal_afe623cbf2e2</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3995355%2F899b57dc-64c1-4089-ac4f-be6d5cb0fa3c.jpg</url>
      <title>DEV Community: rahul bandal</title>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/rahul_bandal_afe623cbf2e2"/>
    <language>en</language>
    <item>
      <title>Understanding Custom Operators in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Wed, 04 Nov 2026 16:51:28 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-custom-operators-in-swift-5hnk</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-custom-operators-in-swift-5hnk</guid>
      <description>&lt;p&gt;Swift is renowned for its clean syntax and powerful features. One such feature, often viewed with both fascination and caution, is the ability to define custom operators. Just as Swift's standard library uses operators like &lt;code&gt;+&lt;/code&gt; for addition, &lt;code&gt;==&lt;/code&gt; for comparison, or &lt;code&gt;!&lt;/code&gt; for logical NOT, you too can create your own symbols to represent specific operations in your code.&lt;/p&gt;

&lt;p&gt;While custom operators can lead to incredibly concise and expressive code, especially within Domain-Specific Languages (DSLs) or mathematical contexts, they also carry the…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingCustomOperatorsInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Computed Properties in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Fri, 30 Oct 2026 15:40:46 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-computed-properties-in-swift-5bda</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-computed-properties-in-swift-5bda</guid>
      <description>&lt;p&gt;As Swift developers, we constantly work with properties to store and manage data within our types. While &lt;em&gt;stored properties&lt;/em&gt; are straightforward data holders, Swift offers a powerful alternative for values that need to be calculated rather than directly stored: &lt;em&gt;computed properties&lt;/em&gt;. These properties don't store a value themselves; instead, they provide a getter to retrieve a value and an optional setter to indirectly modify other stored properties.&lt;/p&gt;

&lt;p&gt;Understanding computed properties is fundamental to writing clean, efficient, and expressive…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingComputedPropertiesInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Lazy Properties in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Thu, 29 Oct 2026 15:56:41 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-lazy-properties-in-swift-3ce2</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-lazy-properties-in-swift-3ce2</guid>
      <description>&lt;p&gt;As Swift developers, we're constantly striving to build efficient and performant applications. One often-overlooked yet powerful feature that can significantly impact your app's startup time and resource usage is the &lt;code&gt;lazy&lt;/code&gt; property. It's a subtle keyword, but mastering its use can lead to cleaner code and a more responsive user experience.&lt;/p&gt;

&lt;p&gt;In this article, we'll dive deep into &lt;code&gt;lazy&lt;/code&gt; properties in Swift, understanding what they are, why and when to use them, and some important considerations to keep in mind.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingLazyPropertiesInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Defer Blocks in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Tue, 27 Oct 2026 15:06:40 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-defer-blocks-in-swift-2ie7</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-defer-blocks-in-swift-2ie7</guid>
      <description>&lt;p&gt;As Swift developers, we're constantly striving for code that is not only functional but also robust, readable, and maintainable. One common challenge arises when dealing with resources that need to be explicitly released or cleaned up after use—think file handles, network connections, mutex locks, or even temporary UI state changes. Forgetting to clean up can lead to resource leaks, deadlocks, or unexpected behavior.&lt;/p&gt;

&lt;p&gt;This is where Swift's &lt;code&gt;defer&lt;/code&gt; statement comes to the rescue. The &lt;code&gt;defer&lt;/code&gt; block allows you to specify code that should be…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingDeferBlocksInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Associated Types in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Sat, 24 Oct 2026 13:05:59 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-associated-types-in-swift-21d0</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-associated-types-in-swift-21d0</guid>
      <description>&lt;p&gt;Swift's protocol-oriented programming paradigm is a cornerstone of its design, enabling flexible and robust code. While you might be familiar with basic protocols and generics, there's a powerful feature that bridges the gap between them: &lt;strong&gt;associated types&lt;/strong&gt;. If you've ever found yourself wishing you could make a protocol generic, but couldn't quite figure out how, associated types are the answer.&lt;/p&gt;

&lt;p&gt;In this article, we'll dive deep into what associated types are, why they're essential, and how to use them effectively to build highly adaptable…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingAssociatedTypesInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Isolation in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Tue, 20 Oct 2026 14:04:33 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-isolation-in-swift-8e2</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-isolation-in-swift-8e2</guid>
      <description>&lt;p&gt;In the world of concurrent programming, ensuring data safety is paramount. When multiple threads or tasks attempt to access and modify shared mutable state simultaneously, chaos can ensue in the form of data races, leading to unpredictable behavior, crashes, and subtle bugs that are notoriously hard to track down. Swift's modern concurrency model, introduced with &lt;code&gt;async/await&lt;/code&gt;, offers powerful mechanisms to tackle these challenges, with &lt;strong&gt;isolation&lt;/strong&gt; being a cornerstone principle.&lt;/p&gt;

&lt;p&gt;At its heart, isolation in Swift concurrency is about…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingIsolationInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Macros in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Sun, 18 Oct 2026 12:57:42 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-macros-in-swift-54kd</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-macros-in-swift-54kd</guid>
      <description>&lt;p&gt;Swift Macros, introduced in Swift 5.9, represent a significant evolution in how developers can generate and transform code. While many developers might be familiar with the basic concept of macros in other languages, Swift's implementation offers a safe, type-checked, and powerful way to reduce boilerplate and create highly expressive APIs without sacrificing compiler guarantees.&lt;/p&gt;

&lt;p&gt;This article goes beyond a basic introduction, aiming to provide a deeper understanding of how Swift Macros work under the hood, their different forms, and how they…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingMacrosInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Result Builders in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Sat, 17 Oct 2026 12:40:59 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-result-builders-in-swift-47da</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-result-builders-in-swift-47da</guid>
      <description>&lt;p&gt;Swift is a language constantly evolving, providing developers with powerful tools to write cleaner, more expressive, and safer code. One such feature, introduced in Swift 5.4, is &lt;strong&gt;Result Builders&lt;/strong&gt; (originally known as Function Builders). While SwiftUI developers interact with them daily without perhaps realizing it, Result Builders are a general-purpose Swift feature that allows you to create highly expressive Domain-Specific Languages (DSLs) and declarative APIs.&lt;/p&gt;

&lt;p&gt;If you've ever written SwiftUI views, you've used a Result Builder. The way…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingResultBuildersInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Dynamic Member Lookup in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Fri, 16 Oct 2026 13:43:40 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-dynamic-member-lookup-in-swift-31hk</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-dynamic-member-lookup-in-swift-31hk</guid>
      <description>&lt;p&gt;Swift is known for its strong type safety and explicit nature, which helps prevent many common programming errors at compile time. However, there are scenarios where a degree of dynamism can be incredibly powerful, allowing for more flexible and expressive APIs. This is where Swift's &lt;code&gt;@dynamicMemberLookup&lt;/code&gt; attribute comes into play.&lt;/p&gt;

&lt;p&gt;Introduced in Swift 4.2 (SE-0195), &lt;code&gt;dynamicMemberLookup&lt;/code&gt; provides a mechanism to intercept and handle member access at runtime. It allows you to define custom behavior for accessing properties that might not…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingDynamicMemberLookupInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding KeyPaths in Swift: Beyond the Basics</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Thu, 15 Oct 2026 13:53:16 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-keypaths-in-swift-beyond-the-basics-367i</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-keypaths-in-swift-beyond-the-basics-367i</guid>
      <description>&lt;p&gt;As Swift developers, we constantly strive for code that is not only functional but also safe, readable, and maintainable. One powerful feature that helps us achieve this, often overlooked or only superficially understood, is Swift's KeyPaths. You might have encountered them briefly, perhaps in SwiftUI bindings or KVO, but truly understanding their capabilities can unlock new patterns for writing more robust and generic code.&lt;/p&gt;

&lt;p&gt;In this article, we'll move beyond a basic introduction to KeyPaths and dive into their different types, practical…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingKeypathsInSwiftBeyondTheBasics/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Type Erasure in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Tue, 13 Oct 2026 16:42:28 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-type-erasure-in-swift-53j8</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-type-erasure-in-swift-53j8</guid>
      <description>&lt;p&gt;Swift's protocol-oriented programming paradigm empowers us to write flexible and modular code. Protocols allow us to define contracts that types can conform to, enabling polymorphism and abstracting away implementation details. However, as you delve deeper into Swift, you'll inevitably encounter a common challenge: protocols with associated types, often referred to as PATs. These powerful constructs, while incredibly useful for creating generic algorithms and data structures, introduce a limitation: you cannot use a PAT directly as a concrete…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingTypeErasureInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
    <item>
      <title>Understanding Value Semantics in Swift</title>
      <dc:creator>rahul bandal</dc:creator>
      <pubDate>Mon, 12 Oct 2026 18:30:58 +0000</pubDate>
      <link>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-value-semantics-in-swift-3fa5</link>
      <guid>https://dev.to/rahul_bandal_afe623cbf2e2/understanding-value-semantics-in-swift-3fa5</guid>
      <description>&lt;p&gt;Swift is a modern, powerful, and safe programming language. A cornerstone of its design philosophy, contributing significantly to its safety and predictability, is its strong emphasis on &lt;strong&gt;value semantics&lt;/strong&gt;. If you've been writing Swift for a while, you've undoubtedly encountered structs, enums, and classes. While you might know when to use each, truly understanding value semantics—and its counterpart, reference semantics—is crucial for writing robust, bug-free, and performant Swift code, especially as your applications grow in complexity and…&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Read the full article on Swift By Rahul&lt;/strong&gt; → &lt;a href="https://www.swiftbyrahul.com/posts/UnderstandingValueSemanticsInSwift/" rel="noopener noreferrer"&gt;Continue reading&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete tutorial includes Swift code examples, SVG diagrams, and step-by-step explanations on our website.&lt;/p&gt;

</description>
      <category>swift</category>
      <category>ios</category>
      <category>programming</category>
    </item>
  </channel>
</rss>
