DEV Community: divyesh vekariya

Swift Mastery Series — Part 18: Swift Async Await

divyesh vekariya — Fri, 23 Oct 2026 14:40:00 +0000

Swift Async/Await

async/await makes asynchronous Swift code easier to follow.

But writing reliable concurrent code also means understanding tasks, cancellation, and structured concurrency.

https://dkvekariya.medium.com/9832bc47fb53

swift #ios #swiftui

Migrating from RxSwift to AsyncSequence and Observable

divyesh vekariya — Tue, 20 Oct 2026 07:50:00 +0000

Swift concurrency gives iOS developers new ways to handle asynchronous work and streams. But migrating from RxSwift isn't always a straightforward replacement.

The important questions are:

When does AsyncSequence make sense?
How can you bridge RxSwift and Swift concurrency?
What should you consider before changing an existing reactive architecture?
How can you migrate incrementally instead of rewriting everything?

I explored these topics in a practical guide for iOS developers working with modern Swift.

Read the complete guide on Medium:

👉 https://dkvekariya.medium.com/fb8e886e0f1e

If you're maintaining an RxSwift codebase, I'd love to hear how you're approaching Swift concurrency.

Are you migrating gradually or keeping your existing reactive architecture?

swift #ios #programming #tutorial

Swift Mastery Series — Part 17: Functional Programming

divyesh vekariya — Fri, 16 Oct 2026 14:30:00 +0000

Functional Programming in Swift

map, filter, and reduce are some of the most useful tools for working with collections.

But the bigger idea is about transforming data, composing operations, and writing predictable code.

A practical look at functional programming in Swift:

https://dkvekariya.medium.com/functional-programming-in-swift-map-filter-reduce-and-beyond-a3ad4bb2ce26

swift #ios #swiftui

Swift Mastery Series — Part 16: Swift Generics

divyesh vekariya — Fri, 09 Oct 2026 14:25:00 +0000

Swift Generics: Write Once, Work With Any Type

Generics help you build reusable code without giving up type safety.

They become especially powerful when combined with:

Generic functions
Type constraints
Protocols
Reusable APIs

A practical guide to understanding generics in Swift.

https://medium.com/@dkvekariya/d6640afccdc9

swift #ios #swiftui

Swift Mastery Series — Part 15: ARC & Memory Management

divyesh vekariya — Fri, 02 Oct 2026 14:25:00 +0000

ARC & Memory Management in Swift

ARC handles much of Swift's memory management for us.

But you still need to understand:

Strong references
Reference cycles
weak vs unowned
Closures and object lifetimes
Common memory leaks

Understanding ownership makes debugging memory issues much easier.

https://medium.com/@dkvekariya/2e9af2ea677f

swift #ios #swiftui

Swift Mastery Series — Part 14: Swift Error Handling

divyesh vekariya — Fri, 25 Sep 2026 14:25:00 +0000

Swift Error Handling: More Than do-catch

Swift gives us several ways to work with failures:

throw and try
do-catch
Result
Propagating errors through APIs

The key isn't knowing the syntax — it's knowing how to model failures clearly.

https://dkvekariya.medium.com/897fb535f805

#swift #ios #swiftui

Swift Mastery Series — Part 13: Swift Extensions

divyesh vekariya — Fri, 18 Sep 2026 15:10:00 +0000

Swift Extensions: More Than Just Convenience

Swift extensions let you add behavior to existing types without subclassing.

They can help with:

Organizing responsibilities
Adding reusable behavior
Improving readability
Keeping types focused

But like any tool, they work best when used with the right design boundaries.

https://dkvekariya.medium.com/swift-extensions-add-behavior-to-any-type-without-subclassing-de5090ae3808

swift #ios #swiftui

Swift Mastery Series — Part 12: Swift Protocols

divyesh vekariya — Fri, 11 Sep 2026 14:40:00 +0000

Swift Protocols Are More Than Contracts

Protocols aren't just about defining requirements.

They can help you design around behavior, composition, and clear responsibilities instead of relying heavily on inheritance.

I explored protocols, conformance, protocol extensions, generics, and Protocol-Oriented Programming with practical Swift examples.

https://medium.com/@dkvekariya/swift-protocols-contracts-conformance-and-protocol-oriented-programming-6b9d48617970

swift #ios #swiftui

Swift Mastery Series — Part 11: Swift Optionals

divyesh vekariya — Fri, 04 Sep 2026 14:15:00 +0000

Optional is one of the first Swift concepts developers learn.

But it's easy to learn the syntax without understanding the reason behind it.

Why does Swift make us explicitly handle missing values?

Because optionals are a fundamental part of Swift's type-safety model.

In this guide, I explore:

What nil actually represents
Optional and its underlying model
if let and guard let
Optional chaining
Nil-coalescing
Common unwrapping mistakes

Understanding the design behind optionals makes the syntax much easier to reason about.

https://medium.com/@dkvekariya/swift-optionals-nil-unwrapping-and-the-safety-system-behind-the-24d48687694f

#swift #ios #swiftui #programming

Swift Mastery Series — Part 10: Swift Enums

divyesh vekariya — Fri, 28 Aug 2026 13:50:00 +0000

A Swift enum can be much more powerful than a simple list of cases.

With associated values, an enum can carry different data for different states.

With raw values, it can represent external values cleanly.

And with pattern matching, you can handle those states in a concise and type-safe way.

This makes enums especially useful for modeling application state and reducing invalid combinations of properties.

I put together a practical guide covering these concepts and how to use them effectively in real Swift projects.

https://medium.com/@dkvekariya/swift-enums-associated-values-raw-values-and-pattern-matching-a5844461beb1

swift #ios #swiftui #programming

Swift Mastery Series — Part 9: Swift Classes: Reference Types, Inheritance & When to Use Them

divyesh vekariya — Mon, 24 Aug 2026 12:20:00 +0000

Swift encourages developers to prefer value types.

So when should you actually use a class?

Classes become useful when your model needs:

Reference semantics
Identity
Shared mutable state
Inheritance
A shared lifecycle

The important part isn't memorizing the differences between struct and class.

It's understanding why reference semantics are sometimes necessary.

In this guide, I explore Swift classes, reference types, inheritance, and the situations where a class is the better design choice.

https://medium.com/@dkvekariya/swift-classes-reference-types-inheritance-and-when-to-use-them-f7a1fd4bd47c

#swift #ios #swiftui #programming

Swift Mastery Series — Part 8: Swift Structs: Why Apple Chooses Value Types Over Classes

divyesh vekariya — Fri, 14 Aug 2026 14:45:00 +0000

One of the biggest mindset shifts in Swift is realizing that struct isn't a lightweight version of class.

It's a deliberate design choice.

In this article, I cover:

Why Apple recommends value types
struct vs class
Value vs reference semantics
Copy-on-Write
Performance and concurrency benefits
When a class is still the right choice

If you've ever wondered why Swift favors struct, this guide explains the reasoning behind it.

https://medium.com/@dkvekariya/swift-structs-why-apple-chooses-value-types-over-classes-f60b79aa3659

swift #ios #swiftui #programming