POP vs OOP decision patterns in Swift - Visual Side-by-Side Comparison

Concept Flow - POP vs OOP decision patterns

Start: Need to model behavior

↓

Decide: Use OOP or POP?

↓

OOP: Classes

↓

Use inheritance

↓

Override methods

↓

Use polymorphism

↓

Manage shared state

↓

End: Behavior modeled

Start by deciding if you want to use classes (OOP) or protocols and structs (POP). OOP uses inheritance and shared state, POP uses protocol conformance and value types.

Execution Sample

Swift

protocol Vehicle {
    func drive()
}

class Car: Vehicle {
    func drive() { print("Car driving") }
}

struct Bike: Vehicle {
    func drive() { print("Bike driving") }
}

Defines a Vehicle protocol, then a Car class and Bike struct that both implement drive() differently.

Execution Table

Step	Action	Type	Method Called	Output
1	Create Car instance	Class	-	-
2	Call drive() on Car	Class	drive()	Car driving
3	Create Bike instance	Struct	-	-
4	Call drive() on Bike	Struct	drive()	Bike driving
5	Assign Car to Vehicle variable	Class	-	-
6	Assign Bike to Vehicle variable	Struct	-	-
7	Call drive() on Vehicle (Car)	Class	drive()	Car driving
8	Call drive() on Vehicle (Bike)	Struct	drive()	Bike driving
9	End of example	-	-	-

💡 All instances called their own drive() method, showing polymorphism in OOP and protocol conformance in POP.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	After Step 6	Final
car	nil	Car instance	Car instance	Car instance	Car instance	Car instance
bike	nil	nil	Bike instance	Bike instance	Bike instance	Bike instance
vehicleCar	nil	nil	nil	Car instance	Car instance	Car instance
vehicleBike	nil	nil	nil	nil	Bike instance	Bike instance

Key Moments - 3 Insights

Why does the Car class allow method overriding but the Bike struct does not?

Because Car is a class (OOP) supporting inheritance and method overriding, while Bike is a struct (POP) which is a value type and does not support inheritance.

How does protocol conformance enable polymorphism in both OOP and POP?

Both Car and Bike conform to the Vehicle protocol, so variables typed as Vehicle can hold either type and call drive(), as shown in steps 7 and 8.

Why might you choose POP over OOP for shared state management?

POP prefers value types like structs which avoid shared mutable state, making code safer and easier to reason about compared to OOP classes that share state.

Visual Quiz - 3 Questions

Look at the execution table, what is the output when calling drive() on the Bike instance at step 4?

A "Car driving"

B "Bike driving"

C No output

D Error

💡 Hint

Check row with Step 4 in execution_table where drive() on Bike is called.

At which step is the Car instance assigned to a variable typed as Vehicle?

A Step 5

B Step 3

C Step 1

D Step 6

💡 Hint

Look for assignment actions in execution_table rows.

If Bike was changed from a struct to a class, which behavior would change?

A Bike would lose drive() method

B Bike would no longer conform to Vehicle

C Bike could then override methods

D No change at all

💡 Hint

Refer to key_moments about class vs struct differences.

Concept Snapshot

POP vs OOP decision patterns in Swift:
- OOP uses classes with inheritance and shared state.
- POP uses protocols and structs with value types.
- Use OOP for polymorphism via inheritance.
- Use POP for safer, simpler code with protocol conformance.
- Both can achieve polymorphism via protocols.

Full Transcript

This visual execution shows how to decide between Protocol-Oriented Programming (POP) and Object-Oriented Programming (OOP) in Swift. We start by choosing whether to use classes (OOP) or protocols and structs (POP). The example defines a Vehicle protocol with a drive() method. Then a Car class and a Bike struct both implement drive() differently. The execution table traces creating instances, calling drive(), and assigning to Vehicle-typed variables. It shows polymorphism working in both OOP and POP styles. The variable tracker follows instance assignments. Key moments clarify why classes support method overriding but structs do not, how protocol conformance enables polymorphism, and why POP prefers value types to avoid shared state. The quiz tests understanding of outputs, assignment steps, and behavior changes if Bike was a class. The snapshot summarizes the main differences and when to use each pattern.