Why Protocol-oriented architecture in iOS Swift? - Purpose & Use Cases

The Big Idea

Discover how a simple blueprint can save you from tangled, buggy code!

The Scenario

Imagine building an app where you want many different parts to share some common behavior, like saving data or displaying information. Without a clear plan, you might copy and paste the same code everywhere or create complex class hierarchies that are hard to manage.

The Problem

Copying code leads to mistakes and makes fixing bugs a nightmare. Deep class inheritance chains become confusing and rigid, making it hard to add new features or change existing ones without breaking things.

The Solution

Protocol-oriented architecture lets you define simple blueprints (protocols) for behaviors. Then, any part of your app can adopt these blueprints and provide its own implementation. This keeps your code clean, flexible, and easy to reuse.

Before vs After

✗ Before

class Animal {
  func sound() { print("Some sound") }
}
class Dog: Animal {
  override func sound() { print("Bark") }
}

✓ After

protocol Soundable {
  func sound()
}
struct Dog: Soundable {
  func sound() { print("Bark") }
}

What It Enables

It enables you to build apps that are easier to understand, extend, and maintain by focusing on what things do rather than what they are.

Real Life Example

Think of a music app where different instruments can play sounds. Using protocols, each instrument type just needs to say it can play a sound, and the app can treat them all the same way without messy inheritance.

Key Takeaways

Manual code copying and deep inheritance cause bugs and confusion.

Protocols define clear behavior blueprints for flexible code reuse.

Protocol-oriented architecture makes your app easier to grow and fix.