<?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 Sudheshna Tholikonda on Medium]]></title>
        <description><![CDATA[Stories by Sudheshna Tholikonda on Medium]]></description>
        <link>https://medium.com/@learningwithsude?source=rss-1ec9d3ac7d49------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*98PoSl8WS3HMxFUe2DauTg.png</url>
            <title>Stories by Sudheshna Tholikonda on Medium</title>
            <link>https://medium.com/@learningwithsude?source=rss-1ec9d3ac7d49------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:30:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@learningwithsude/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[Architectural Patterns vs Design Patterns in iOS: What Developers Must Know]]></title>
            <link>https://medium.com/@learningwithsude/architectural-patterns-vs-design-patterns-in-ios-what-developers-must-know-9cce7c189d81?source=rss-1ec9d3ac7d49------2</link>
            <guid isPermaLink="false">https://medium.com/p/9cce7c189d81</guid>
            <category><![CDATA[design-pattern-ios]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[architectural-patterns]]></category>
            <dc:creator><![CDATA[Sudheshna Tholikonda]]></dc:creator>
            <pubDate>Tue, 19 Aug 2025 01:24:02 GMT</pubDate>
            <atom:updated>2025-08-19T01:24:02.130Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong><em>Our Motto</em></strong><em>: “</em><strong>Code with confidence and ship with pride</strong><em>”</em></blockquote><p>As iOS developers, we constantly hear terms like <strong>MVC, MVVM, VIPER, Singleton, Delegate, Factory</strong> … and it’s easy to mix them up.<br> The truth is: <strong>Architectural patterns</strong> and <strong>Design patterns</strong> solve problems at <em>different levels</em> of software development.</p><p>In this article, let’s break down the <strong>differences</strong>, explore popular patterns in iOS, and understand when to use them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OWkcnwkHngPnsczz" /><figcaption>Photo by <a href="https://unsplash.com/@dabbas?utm_source=medium&amp;utm_medium=referral">Dabbas</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Architectural Patterns: The Big Picture</h3><p>Think of <strong>architectural patterns</strong> as the <strong>blueprint of a city</strong>.<br> They define how your app is structured, how data flows, and how responsibilities are divided across layers.</p><p>In iOS, architectural patterns determine <strong>how the UI, business logic, and data interact</strong>.</p><h3>Popular Architectural Patterns in iOS</h3><ol><li><strong>MVC (Model–View–Controller)</strong></li></ol><ul><li>Apple’s default and simplest pattern.</li><li><strong>Model</strong> → Data,<br> <strong>View</strong> → UI,<br> <strong>Controller</strong> → Middleman.</li><li>✅ Easy to implement, great for small apps.</li><li>❌ Leads to <em>Massive View Controllers</em>.</li></ul><p><strong>2. MVVM (Model–View–ViewModel)</strong></p><ul><li>Moves presentation logic into the <strong>ViewModel</strong>.</li><li>Works beautifully with <strong>SwiftUI</strong> (@Published, ObservableObject).</li><li>✅ Better separation of concerns, testable.</li><li>❌ Can overcomplicate for small projects.</li></ul><p><strong>3. MVP (Model–View–Presenter)</strong></p><ul><li>Presenter takes over logic, View just renders.</li><li>✅ Clear responsibilities, easy unit testing.</li><li>❌ Boilerplate code overhead.</li></ul><p><strong>4. VIPER</strong></p><ul><li>Splits into <strong>View, Interactor, Presenter, Entity, Router</strong>.</li><li>✅ Highly modular, scalable for big apps.</li><li>❌ Can feel heavy for small-to-medium apps.</li></ul><p><strong>5. Clean Architecture</strong></p><ul><li>Inspired by Robert C. Martin (Uncle Bob)</li><li>Onion-like layers: <strong>Entities → Use Cases → Interface Adapters → Frameworks/UI</strong>.</li><li>✅ Very testable, long-term maintainability.</li><li>❌ Learning curve, may feel over-engineered for small teams.</li></ul><h3>Design Patterns: The Building Blocks</h3><p>Now, if architecture is the city plan, <strong>design patterns</strong> are the <strong>construction techniques</strong>.<br> They provide <strong>proven, reusable solutions</strong> to recurring coding problems at a smaller scale.</p><p>In iOS, design patterns usually guide <strong>class relationships, object creation, and communication</strong>.</p><h3>Common Design Patterns in iOS</h3><ol><li><strong>Singleton</strong></li></ol><ul><li>One shared instance across the app.</li><li>Example: UserDefaults.standard, FileManager.default.</li></ul><p><strong>2. Delegate</strong></p><ul><li>One-to-one communication between objects.</li><li>Example: UITableViewDelegate, UITextFieldDelegate.</li></ul><p><strong>3. Observer</strong></p><ul><li>One-to-many communication.</li><li>Example: NotificationCenter, Combine’s Publisher.</li></ul><p><strong>4. Factory</strong></p><ul><li>Centralized object creation.</li><li>Example: URLSession(configuration:).</li></ul><p><strong>5. Adapter</strong></p><ul><li>Bridge between incompatible interfaces.</li><li>Example: Wrapping Core Data models for SwiftUI views.</li></ul><p><strong>6. Strategy</strong></p><ul><li>Swap algorithms at runtime.</li><li>Example: Different sorting strategies for a list.</li></ul><p><strong>7. Facade</strong></p><ul><li>Simple interface to a complex system.</li><li>Example: UIKit hides Core Graphics complexity.</li></ul><p><strong>8. Builder</strong></p><ul><li>Step-by-step object construction.</li><li>Example: Building URLRequest with headers, body, method.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*04K9LJeQpQMR5uI3ODxbww.png" /></figure><h3>When to Use What?</h3><ul><li>Use an <strong>Architectural Pattern</strong> when you’re deciding the <strong>overall app structure</strong> before starting development.</li><li>Use a <strong>Design Pattern</strong> when solving <strong>specific coding challenges</strong> (object creation, communication, state management).</li></ul><p>Most real-world iOS apps combine both.<br> Example: An app might follow <strong>MVVM (architecture)</strong> while using <strong>Delegates, Observers, and Factories (design patterns)</strong> inside.</p><h3>✅ Final Thoughts</h3><p>Architectural patterns give your app a <strong>strong backbone</strong>, while design patterns provide the <strong>muscles and joints</strong> to make it move.</p><p>As you grow as an iOS developer, you’ll realize it’s not about picking one pattern but <strong>knowing when to apply the right mix</strong>.<br> Master both, and you’ll write apps that are <strong>scalable, testable, and maintainable</strong> — exactly what every team and company wants.</p><p>🔥 <strong>Next Steps:</strong> In future articles, I’ll dive deeper into <strong>MVVM in SwiftUI</strong> and explore how <strong>Combine</strong> and <strong>async/await</strong> reshape traditional design patterns. Stay tuned!</p><p>💡 <strong>Follow me for more</strong> deep dives into iOS development to level up your Swift skills and build faster, smoother apps. Happy Coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9cce7c189d81" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concurrency in iOS — The Complete Guide for Developers]]></title>
            <link>https://medium.com/@learningwithsude/concurrency-in-ios-the-complete-guide-for-developers-b4fb23b13b93?source=rss-1ec9d3ac7d49------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4fb23b13b93</guid>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[swift-concurrency]]></category>
            <category><![CDATA[gcd]]></category>
            <category><![CDATA[operationqueue]]></category>
            <dc:creator><![CDATA[Sudheshna Tholikonda]]></dc:creator>
            <pubDate>Thu, 14 Aug 2025 03:12:35 GMT</pubDate>
            <atom:updated>2025-08-14T03:12:35.651Z</atom:updated>
            <content:encoded><![CDATA[<h3>Concurrency in iOS — The Complete Guide for Developers</h3><blockquote><strong>Our Motto</strong>: “<strong><em>Code with confidence and ship with pride</em></strong>”</blockquote><p>If you’ve been developing iOS apps for a while, you’ve probably noticed that some tasks — like loading images from the web, syncing data, or parsing large JSON files — can make your UI freeze if you run them on the main thread. This is where <strong>concurrency</strong> comes in.</p><p>Concurrency in iOS is all about <strong>running multiple tasks seemingly at the same time</strong> so your main thread isn’t blocked. The key is to <strong>keep heavy work off the main thread</strong> while keeping the UI buttery smooth.</p><h3>Why Concurrency Matters in iOS</h3><ul><li><strong>Smooth UI:</strong> Keep animations and interactions responsive.</li><li><strong>Efficiency:</strong> Use device resources more effectively.</li><li><strong>Better User Experience:</strong> Reduce waiting times for heavy operations like API calls or image processing.</li></ul><p>If you do everything on the <strong>main thread</strong>, your app will stutter or freeze during heavy work. Concurrency offloads work to background threads while keeping UI updates on the main thread.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*ercoAGtisRIVzMMznJAx5w.png" /></figure><h3>Core Concurrency Concepts in iOS</h3><h3>1. Threads</h3><p>A thread is the smallest unit of execution. iOS creates multiple threads, but you don’t manually create them often — instead, you use <strong>GCD</strong> or <strong>OperationQueue</strong> to manage them.</p><h3>2. Main Thread vs. Background Thread</h3><ul><li><strong>Main Thread:</strong> Handles UI updates. Never block it.</li><li><strong>Background Thread:</strong> Runs heavy tasks like network requests, file I/O, or computation.</li></ul><h3>🚀 Concurrency Tools in iOS</h3><h3>1. Grand Central Dispatch (GCD)</h3><p>A low-level C API that’s fast and easy to use for most concurrency needs.</p><ul><li><strong>Serial Queue:</strong> Executes tasks one after another.</li><li><strong>Concurrent Queue:</strong> Executes multiple tasks at the same time.</li><li><strong>Main Queue:</strong> Special serial queue for UI updates.</li></ul><pre>DispatchQueue.global(qos: .background).async {<br>    // Heavy task<br>    let data = fetchDataFromServer()<br>    <br>    DispatchQueue.main.async {<br>        // Update UI<br>        self.updateUI(with: data)<br>    }<br>}</pre><h3>2. Operation &amp; OperationQueue</h3><p>A higher-level, object-oriented API for concurrency.</p><ul><li>Supports dependencies between tasks.</li><li>More control over cancelling, prioritizing, and reusing tasks.</li></ul><pre>let queue = OperationQueue()<br>queue.addOperation {<br>    let result = processData()<br>    <br>    OperationQueue.main.addOperation {<br>        self.display(result)<br>    }<br>}</pre><h3>3. Swift Concurrency (async/await &amp; Task)</h3><p>Introduced in Swift 5.5, this modern approach makes asynchronous code more readable and maintainable.</p><pre>func loadUserProfile() async {<br>    let profile = await fetchProfile()<br>    updateUI(with: profile)<br>}<br><br>Task {<br>    await loadUserProfile()<br>}</pre><h3>Best Practices for Concurrency in iOS</h3><ul><li><strong>Never update UI from a background thread.</strong> Always switch back to the main thread.</li><li><strong>Use QoS (Quality of Service):</strong> Match priority with the task type.</li><li><strong>Avoid race conditions:</strong> Protect shared resources with locks or actors.</li><li><strong>Don’t create too many threads:</strong> Let the system manage thread scheduling.</li></ul><h3>🤝 Final Thoughts</h3><p>Concurrency is not just about speed — it’s about <strong>maintaining a fluid, responsive experience</strong> for the user. In modern iOS development, <strong>Swift concurrency</strong> with async/await is the go-to choice for readability, while <strong>GCD</strong> and <strong>OperationQueue</strong> still have their place for more fine-grained control.</p><p>If you master concurrency, you’ll not only prevent app freezes but also design apps that feel <em>instantaneous</em> and professional.</p><p>💡 <strong>Follow me for more</strong> deep dives into iOS development — including <strong>concurrency</strong>, <strong>multi-threading</strong>, and <strong>async/await</strong> — to level up your Swift skills and build faster, smoother apps. Happy Coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4fb23b13b93" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Swift 6 Migration Masterclass: Concurrency Safety, Typed Throws, and the Path to Future-Proof Apps]]></title>
            <link>https://medium.com/@learningwithsude/swift-6-migration-masterclass-concurrency-safety-typed-throws-and-the-path-to-future-proof-apps-ff5b4b33ccf4?source=rss-1ec9d3ac7d49------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff5b4b33ccf4</guid>
            <category><![CDATA[swift-concurrency]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[swift-6]]></category>
            <category><![CDATA[migrating-to-swift-6]]></category>
            <category><![CDATA[wwdc]]></category>
            <dc:creator><![CDATA[Sudheshna Tholikonda]]></dc:creator>
            <pubDate>Wed, 13 Aug 2025 00:19:29 GMT</pubDate>
            <atom:updated>2025-08-13T00:19:29.153Z</atom:updated>
            <content:encoded><![CDATA[<p>Learn how to migrate to Swift 6 with confidence. This in-depth guide covers strict concurrency checks, data-race safety, typed throws, and a step-by-step migration plan for safer, faster, and more maintainable iOS apps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/452/1*2XaRX-U-lkhWyB6KEH_KyQ.png" /></figure><h3>🚀 Swift 6 Is Here — And It’s a Game-Changer</h3><p>Released in <strong>September 2024</strong>, Swift 6 is not just a routine upgrade — it’s a <em>paradigm shift</em>. With <strong>data-race safety by default</strong>, <strong>strict concurrency enforcement</strong>, and <strong>typed throws</strong>, this release transforms the way we build iOS, macOS, and server-side Swift apps.</p><p>If you treat this migration like a “just change the version number” task, you’ll miss the deeper opportunity: to build apps that are <strong>safer, cleaner, and future-proof</strong>.</p><h3>🧠 <strong>Key Changes Every Developer Must Understand</strong></h3><h3>1️⃣ Data-Race Safety as a Language Feature (by Default)</h3><ul><li>In Swift 5.x, you could write unsafe concurrent code without the compiler complaining.</li><li>In Swift 6, unsafe concurrent access is <strong>an error</strong>, not a warning.</li></ul><pre>var counter = 0<br><br>Task.detached {<br>    counter += 1 // ❌ Swift 6 error — possible data race<br>}</pre><p><strong>Fix:</strong> Encapsulate in an actor or use a synchronization primitive.</p><pre>actor Counter {<br>    private var value = 0<br>    func increment() { value += 1 }<br>}</pre><h3>2️⃣ Strict Concurrency Checking</h3><p>Swift 6 introduces <strong>full enforcement</strong> of Sendable conformance and MainActor isolation.</p><ul><li>Functions running in a different concurrency domain must work only with Sendable types. Non-Sendable types can’t cross async threads.</li><li>UI updates must be isolated to MainActor.</li></ul><pre>@MainActor<br>class DashboardViewModel {<br>    func refreshUI() { /* safe UI work */ }<br>}</pre><h3>3️⃣ Typed Throws</h3><p>Define exactly what error type a function can throw.</p><pre>enum NetworkError: Error { case timeout, invalidResponse }<br><br>func fetchData() throws(NetworkError) {<br>    // Only NetworkError can be thrown<br>}</pre><h3>4️⃣ Scoped Imports</h3><p>Limit visibility and prevent dependency creep:</p><pre>private import MyInternalLib</pre><h3>5️⃣ Low-Level Concurrency Tools</h3><p>Swift now ships a synchronization library:</p><ul><li>Atomic values</li><li>Mutex wrappers</li><li>Fine-grained concurrency control</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*vxQrLobUD83sgzftrMjNEg.png" /></figure><h3>🛠 <strong>The Swift 6 Migration Blueprint</strong></h3><h3>Step 1 — Audit Your Codebase</h3><ul><li>Identify shared mutable state and global variables.</li><li>List all concurrency mechanisms ( DispatchQueue, OperationQueue, Combine, async/await).</li><li>Note legacy async patterns.</li></ul><h3>Step 2 — Enable Upcoming Features Gradually</h3><p>In Xcode → <strong>Build Settings → Swift Compiler → Upcoming Features</strong>:</p><ol><li>Enable <strong>Strict Concurrency Checking</strong> (Minimal → Targeted → Complete).</li><li>Turn on <strong>Data-Race Safety Checks</strong>.</li><li>Move to <em>Targeted</em> and finally <em>Complete</em> after fixes.</li></ol><h3>Step 3 — Fix Compiler Feedback</h3><ul><li>Replace shared mutable state with actors.</li><li>Annotate with @Sendable, @MainActor, or nonisolated.</li><li>Conform custom types to Sendable.</li></ul><h3>Step 4 — Migrate Module-by-Module</h3><ul><li>Start with Swift Packages or isolated components.</li><li>Test each migration step before moving forward.</li></ul><h3>Step 5 — Finalize</h3><p>Switch project to <strong>Swift 6 mode</strong> → all concurrency warnings become errors → future-safe by default.</p><h3>📈 Pro Tips for a Smooth Migration</h3><ul><li><strong>Leverage Actors Early</strong>: They simplify isolation and race avoidance.</li><li><strong>Prefer Async/Await Over Callbacks</strong>: Reduces cognitive load and aligns with compiler checks.</li><li><strong>Test in Parallel</strong>: Run migration on a feature branch while continuing active dev on main.</li><li><strong>Educate the Team</strong>: Even experienced devs may need a concurrency refresher.</li></ul><h3>🎯 <strong>Beyond Migration — The Bigger Win</strong></h3><p>Swift 6 isn’t just about passing the compiler’s checks. It’s about <strong>leveraging the compiler as your co-pilot</strong> to avoid subtle concurrency bugs, increase maintainability, and prepare for Swift 7+.</p><p><strong>The takeaway:</strong> Don’t aim for “compiles without errors.” Aim for <strong>Swift 6-optimized code</strong>.</p><ul><li>Safer in production</li><li>Easier to maintain</li><li>Ready for Swift 7 and beyond</li></ul><h3>📚 Further Reading</h3><p><a href="https://www.swift.org/migration/documentation/migrationguide/">Swift.org Migration Guide</a></p><p><a href="https://www.avanderlee.com/concurrency/swift-6-migrating-xcode-projects-packages/">SwiftLee — Migrating to Swift 6</a></p><p><a href="https://developer.apple.com/videos/play/wwdc2024/10169/">WWDC 2024 — Concurrency in Swift 6</a></p><p>💡 <em>You’re not just migrating — you’re evolving your app into a safer, smarter, and more future-ready version of itself.</em></p><p>✍️ <em>Follow for more iOS dev tips, Swift concepts, and architecture patterns. Happy coding!</em></p><p>Swift iOS Development Concurrency Programming Software Engineering</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff5b4b33ccf4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Combine and Reactive Programming in iOS: What They Are and How They’re Related]]></title>
            <link>https://medium.com/@learningwithsude/combine-and-reactive-programming-in-ios-what-they-are-and-how-theyre-related-94097484e399?source=rss-1ec9d3ac7d49------2</link>
            <guid isPermaLink="false">https://medium.com/p/94097484e399</guid>
            <dc:creator><![CDATA[Sudheshna Tholikonda]]></dc:creator>
            <pubDate>Thu, 31 Jul 2025 06:03:01 GMT</pubDate>
            <atom:updated>2025-07-31T06:03:01.699Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re building modern iOS apps and have heard terms like <strong>Combine</strong> and <strong>Reactive Programming</strong>, but you’re not quite sure how they fit together — this post is for you.</p><p>Let’s demystify the concepts and understand how Apple’s <strong>Combine framework</strong> helps bring <strong>reactive programming</strong> into the Swift ecosystem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*o7XY3oqX2hgvYf2Ug1k-Mg.png" /></figure><h3>What Is Reactive Programming?</h3><p><strong>Reactive Programming</strong> is a <strong>programming paradigm</strong> focused on handling <strong>asynchronous data streams</strong> and <strong>reacting to changes</strong> over time.</p><p>In simple terms, it means:</p><blockquote><em>“When one piece of data changes, everything that depends on it should update automatically.”</em></blockquote><p>Think of it like <strong>Excel formulas</strong> — when you change one cell, any dependent cells update without you doing anything extra.</p><p>This concept is incredibly useful for:</p><ul><li>UI updates based on user input</li><li>Networking (e.g., chaining API calls)</li><li>Form validation</li><li>Event handling</li></ul><h3>What Is Combine?</h3><p><strong>Combine</strong> is Apple’s <strong>declarative framework</strong> for working with <strong>asynchronous events</strong> and <strong>reactive streams</strong> in Swift.</p><p>Introduced in <strong>iOS 13</strong>, Combine helps you:</p><ul><li>Listen to events like button taps, text changes, or network responses</li><li>Transform and filter data with operators</li><li>Automatically respond to changes using subscribers</li></ul><p>🔑 Key Concepts in Combine:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/1*rua4zHBf36Asg1FTOWfBPw.png" /></figure><p>Here’s a simple example:</p><pre>import Combine<br><br>let publisher = Just(&quot;Hello, Combine!&quot;)<br>let subscription = publisher<br>    .sink { value in<br>        print(value)<br>    }</pre><p>This prints:<br> Hello, Combine!</p><h3>🔗 How Are Combine and Reactive Programming Related?</h3><p>To put it plainly:</p><blockquote><strong><em>Reactive Programming is the theory. Combine is Apple’s tool to put that theory into practice.</em></strong></blockquote><ul><li><strong>Reactive Programming</strong> is <strong>language-agnostic</strong> and used in many ecosystems (e.g., RxJava, RxJS, RxSwift).</li><li><strong>Combine</strong> is Apple’s <strong>native Swift implementation</strong> that brings reactive concepts to iOS, macOS, watchOS, and tvOS.</li></ul><h3>🧪 Real-World Example</h3><p>Let’s say you want to enable a <strong>Submit</strong> button only when both a username and password field are valid.</p><h4>With Combine:</h4><pre>usernamePublisher<br>    .combineLatest(passwordPublisher)<br>    .map { username, password in<br>        return !username.isEmpty &amp;&amp; password.count &gt; 5<br>    }<br>    .assign(to: \.isEnabled, on: submitButton)</pre><p>This is a textbook case of <strong>reactive programming</strong> — you define how the system should <strong>react</strong> when any part of the input changes, and <strong>Combine</strong> handles the wiring for you.</p><h3>🤝 Combine vs Other Reactive Frameworks</h3><p>Combine is not the first reactive framework in iOS. Others include:</p><ul><li><strong>RxSwift</strong></li><li><strong>ReactiveSwift</strong></li></ul><p>But unlike them, Combine is:</p><ul><li><strong>Built by Apple</strong></li><li><strong>Deeply integrated</strong> into Swift and SwiftUI</li><li>Comes with <strong>first-party support and updates</strong></li></ul><p>If you’re working in a modern SwiftUI or UIKit project, Combine is often the best fit.</p><h3>🧵 Summary</h3><ul><li><strong>Reactive Programming</strong> is a way of thinking: “Let data changes flow and react automatically.”</li><li><strong>Combine</strong> is Apple’s official tool to write apps in this reactive style.</li><li>Combine provides <strong>Publishers</strong>, <strong>Operators</strong>, and <strong>Subscribers</strong> to build clean, scalable, and reactive iOS applications.</li></ul><h3>🚀 Final Thoughts</h3><p>Combine is powerful — but it requires a shift in thinking. Once you embrace <strong>reactive patterns</strong>, you’ll notice:</p><ul><li>Less boilerplate</li><li>More predictable code</li><li>Easier handling of complex async logic</li></ul><p>If you’re diving into SwiftUI or want a better way to handle user interaction, Combine is definitely worth learning.</p><p>✍️ <em>Follow for more iOS dev tips, Swift concepts, and architecture patterns. Happy coding!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94097484e399" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stack vs Heap Memory in Programming: Explained Simply with Examples]]></title>
            <link>https://medium.com/@learningwithsude/stack-vs-heap-memory-in-programming-explained-simply-with-examples-62b1346d2eaf?source=rss-1ec9d3ac7d49------2</link>
            <guid isPermaLink="false">https://medium.com/p/62b1346d2eaf</guid>
            <category><![CDATA[stack]]></category>
            <category><![CDATA[heap-and-stack-memory]]></category>
            <category><![CDATA[stackoverflow]]></category>
            <category><![CDATA[memory-management]]></category>
            <category><![CDATA[heap]]></category>
            <dc:creator><![CDATA[Sudheshna Tholikonda]]></dc:creator>
            <pubDate>Mon, 07 Jul 2025 12:12:44 GMT</pubDate>
            <atom:updated>2025-07-07T12:12:44.434Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*iVusrIHeQKtZawqgbxJxcg.jpeg" /></figure><p>When writing code, you’ve probably heard the terms <strong>stack</strong> and <strong>heap</strong> memory. These are the two major areas of memory used during runtime. Understanding how they work can help you write more efficient, bug-free code — especially in languages like Swift, C++, Java, or even Python.</p><p>Let’s dive in.</p><p><strong>What Is Stack Memory?</strong></p><p><strong>Stack memory</strong> is a region where function calls, local variables, and control flow data are stored. Think of it as a stack of plates — Last In, First Out (LIFO).</p><h4>Characteristics:</h4><ul><li><strong>Fast allocation and deallocation</strong> ✅</li><li><strong>Managed automatically</strong> 🛠️</li><li><strong>Fixed size</strong> 📏</li><li><strong>Stores local variables and function calls</strong> 🔁</li></ul><pre>func addNumbers() {<br>    let a = 5<br>    let b = 10<br>    let result = a + b<br>    print(result)<br>}<br>Here, a, b, and result are stored on the stack.</pre><p><strong>What Is Heap Memory?</strong></p><p><strong>Heap memory</strong> is a region for dynamic memory allocation — used when you create objects, arrays, or structures that need to persist or grow during runtime.</p><h4>Characteristics:</h4><ul><li><strong>Slower access than stack</strong> 🐢</li><li><strong>Manually managed (in some languages)</strong> ⚠️</li><li><strong>Larger in size</strong> 📦</li><li><strong>Used for objects, closures, and class instances</strong> 🧩</li></ul><pre>class Car {<br>    var model: String<br>    init(model: String) {<br>        self.model = model<br>    }<br>}<br><br>let myCar = Car(model: &quot;Tesla&quot;)</pre><p>Here, the object myCar is stored on the <strong>heap</strong>, but the reference to it is on the <strong>stack</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*SOT0KvvWEh0VyE87KMfYFQ.png" /></figure><h3>🛠 Why Does This Matter?</h3><ul><li><strong>Performance:</strong> Frequent heap allocations can slow down your app.</li><li><strong>Memory Leaks:</strong> Forgetting to release heap memory (in languages without automatic GC) causes leaks.</li><li><strong>Thread Safety:</strong> Stack memory is thread-safe; heap is shared between threads.</li><li><strong>Crash Risk:</strong> Stack overflow (too many nested calls) is a common crash cause.</li></ul><h3>👩‍💻 In Swift (ARC Perspective)</h3><p>Swift uses <strong>Automatic Reference Counting (ARC)</strong> to manage heap memory. It tracks how many references point to an object — when the count hits zero, the memory is freed. But beware:</p><pre>class A {<br>    var b: B?<br>}<br>class B {<br>    var a: A?<br>}</pre><p>This <strong>retain cycle</strong> keeps both in memory forever unless broken manually. Use [weak] or [unowned] to avoid it.</p><h3>✅ Final Thoughts</h3><p>Understanding the difference between stack and heap helps you:</p><ul><li>Write efficient, memory-safe code</li><li>Avoid performance bottlenecks</li><li>Debug crashes more effectively</li><li>Stack: for short-lived, local variables. Fast but limited.</li><li>Heap: for dynamic, long-lived objects. Flexible but slower.</li></ul><p>💬 <em>Have you encountered a stack overflow or memory leak recently? Drop your story in the comments!</em></p><h3>🙌 Let’s Connect!</h3><p>If you found this guide helpful, feel free to:</p><ul><li>Share your thoughts in the comments</li><li>Or message me on LinkedIn!</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62b1346d2eaf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Beginner’s Guide to Getting Started with GitHub: Create Your Account, Repositories, and Upload…]]></title>
            <link>https://medium.com/@learningwithsude/a-beginners-guide-to-getting-started-with-github-create-your-account-repositories-and-upload-de6aa256f73c?source=rss-1ec9d3ac7d49------2</link>
            <guid isPermaLink="false">https://medium.com/p/de6aa256f73c</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[how-to]]></category>
            <category><![CDATA[beginners-guide]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[portfolio]]></category>
            <dc:creator><![CDATA[Sudheshna Tholikonda]]></dc:creator>
            <pubDate>Fri, 04 Jul 2025 07:55:15 GMT</pubDate>
            <atom:updated>2025-07-04T08:02:04.468Z</atom:updated>
            <content:encoded><![CDATA[<h3>A Beginner’s Guide to Getting Started with GitHub: Create Your Account, Repositories, and Upload Projects</h3><p>If you’re new to coding or just starting your tech journey, GitHub can feel a little intimidating. But don’t worry — in this guide, I’ll walk you through the <strong>complete beginner-friendly process</strong> of getting started with GitHub: creating an account, setting up your first repository, and uploading your personal projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VMzp8Ywz7KUyJ8PU" /><figcaption>Photo by <a href="https://unsplash.com/@synkevych?utm_source=medium&amp;utm_medium=referral">Roman Synkevych</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>🌐 What Is GitHub (and Why Should You Care)?</h3><p>GitHub is a platform for <strong>storing your code online</strong>, <strong>collaborating with others</strong>, and <strong>tracking the history of your projects</strong>. Whether you’re building a portfolio, working on open-source, or collaborating with a team — GitHub is where it all happens.</p><p>GitHub allows you to:</p><ul><li>Store your code safely online</li><li>Track changes and project history</li><li>Share and collaborate with others</li><li>Build a public portfolio to impress employers</li></ul><h3>📝 Step 1: Creating Your GitHub Account</h3><ol><li>Visit <a href="https://github.com/">https://github.com</a></li><li>Click <strong>Sign Up</strong> (if you don’t already have an account)</li><li>Choose the <strong>Free plan</strong> unless you need advanced private collaboration tools</li><li>Verify your email address to activate the account</li></ol><h3>📁 Step 2: Creating Your First Repository</h3><p>A repository (or <strong>repo</strong>) is like a folder where your project lives.</p><h3>Here’s how to create one:</h3><ol><li>Log in to GitHub</li><li>On the top-right corner, click the <strong>+</strong> icon → <strong>New repository</strong></li><li>Fill in the details:</li></ol><ul><li><strong>Repository name</strong>: e.g., portfolio-website</li><li>Add a <strong>description</strong> (optional but recommended)</li><li>Choose <strong>Public</strong> or <strong>Private</strong></li><li>✅ Check “<strong>Initialize this repository with a README</strong>”</li></ul><blockquote><em>✅ Tip: It’s best practice to create one repository per project.</em></blockquote><h3>💻 Step 3: Uploading Your Local Project to GitHub</h3><p>There are two ways: <strong>Manual upload</strong> (via browser) and <strong>Command line Git</strong>.</p><h3>Method A: Upload via GitHub Website (for small projects)</h3><ol><li>Open your repository</li><li>Click <strong>“Add file” → “Upload files”</strong></li><li>Drag and drop your project files or browse to select them</li><li>Write a commit message (e.g., “Initial project upload”)</li><li>Click <strong>Commit changes</strong></li></ol><h3><strong>Method B: Upload via Git (Recommended for coding workflow)</strong></h3><h4>1. Install Git</h4><ul><li>Download from: <a href="https://git-scm.com/">https://git-scm.com</a></li><li>Install with default settings</li></ul><p>2. Open your terminal / Git Bash</p><pre>cd path/to/your/project<br>git init<br>git add .<br>git commit -m &quot;Initial commit&quot;</pre><p>3. Connect your local project to GitHub</p><p>Get your repo URL from GitHub (e.g., https://github.com/yourusername/portfolio-website.git), then:</p><pre>git remote add origin https://github.com/yourusername/portfolio-website.git<br>git branch -M main<br>git push -u origin main</pre><p>🎉 Your project is now online on GitHub!</p><p>Best Practices for Beginners</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/1*EIPpJuUq3Mz_VT56sGQRPg.png" /><figcaption>Always follow these practices</figcaption></figure><h3>🎯 Conclusion</h3><p>Whether you’re a student, developer, or hobbyist — learning to use GitHub is one of the most valuable skills in tech today. It helps you <strong>organize your code</strong>, <strong>build a public portfolio</strong>, and <strong>collaborate with the world</strong>.</p><blockquote><em>📌 Remember: You don’t need to know everything about Git to get started. </em><strong>Start small. Upload one project. Learn as you go.</strong><br> Each push you make builds your portfolio and grows your confidence.</blockquote><h3>🙌 Let’s Connect!</h3><p>If you found this guide helpful, feel free to:</p><ul><li>Share your thoughts in the comments</li><li>Or message me on LinkedIn!</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de6aa256f73c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>