Why functional patterns complement OOP in Ruby - Visual Breakdown

Concept Flow - Why functional patterns complement OOP

Start with OOP design

↓

Identify mutable state and side effects

↓

Apply functional patterns

↓

Use pure functions and immutability

↓

Reduce bugs and improve testability

↓

Combine OOP and functional for better code

This flow shows how starting from object-oriented design, adding functional patterns like pure functions and immutability helps reduce bugs and improve code quality.

Execution Sample

Ruby

class Counter
  def initialize
    @count = 0
  end

  def increment
    @count += 1
  end

  def value
    @count
  end
end

# Functional style increment
def increment(count)
  count + 1
end

c = Counter.new
c.increment
puts c.value

count = 0
count = increment(count)
puts count

This code shows a simple OOP counter with mutable state and a functional increment function that returns a new value without changing state.

Execution Table

Step	Action	OOP @count	Functional count	Output
1	Create Counter instance c	0	N/A	N/A
2	Call c.increment	1	N/A	N/A
3	Call c.value	1	N/A	1
4	Initialize functional count = 0	1	0	N/A
5	Call increment(count)	1	1	N/A
6	Print functional count	1	1	1

💡 Execution ends after printing both OOP and functional counter values.

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
@count (OOP)	0	1	1	1
count (Functional)	0	0	1	1

Key Moments - 2 Insights

Why does the OOP counter use @count while the functional version uses count as a parameter?

In the OOP version, @count is an internal state variable that changes inside the object (see Step 2). In the functional version, count is passed in and a new value is returned without changing the original (see Step 5).

Why is the functional count updated by assignment after calling increment?

Because functional increment returns a new value instead of changing state, you must assign the result back to count to keep the updated value (see Step 5 and 6).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of @count after Step 2?

A 1

B 0

C N/A

D 2

💡 Hint

Check the 'OOP @count' column at Step 2 in the execution_table.

At which step does the functional count change from 0 to 1?

A Step 2

B Step 5

C Step 3

D Step 6

💡 Hint

Look at the 'Functional count' column in the execution_table.

If the functional increment did not return a new value, what would happen to count after Step 5?

A count would become 1

B count would become nil

C count would remain 0

D count would cause an error

💡 Hint

Refer to variable_tracker and understand that functional increment returns a new value to update count.

Concept Snapshot

OOP uses objects with internal state (mutable variables).
Functional patterns use pure functions and immutable data.
Combining them reduces bugs and improves testability.
Functional code avoids side effects by returning new values.
Use functional methods inside OOP to complement design.

Full Transcript

This visual execution shows how functional programming patterns complement object-oriented programming. We start with an OOP Counter class that keeps internal mutable state in @count. Calling increment changes @count inside the object. Separately, a functional increment function takes a count value and returns a new incremented value without changing the original. The execution table traces each step: creating the object, incrementing the OOP counter, printing its value, then using the functional increment and printing that result. The variable tracker shows how @count changes inside the object, while count is updated by assignment in the functional style. Key moments clarify why OOP uses internal state and functional style returns new values. The quiz tests understanding of state changes and differences between OOP and functional updates. This combination helps write clearer, less error-prone code by mixing mutable objects with pure functions.