# Discussion on: OOP vs Functional Programming

Kaveh Shahbazian

Let's assume that we can question everything that is assumed to be a fact (or ask stupid questions - your take).

# OOP was about message passing

Apparently, the language that is most close to the original idea of OOP, is ... Erlang! According to Alan Kay (mentioned this on different occassions).

# Closures & Functional Programming

Here we are cheating a bit, just to communicate better. We can blame things after.

``````const (
factor = 10
)

func add10(n int) int      { return n + factor }
func multiply10(n int) int { return n * factor }
``````

Here, only functions are used. The `factor` constant, is a closure, accessed inside `add10` and `multiply10` functions. Very Functional so far.

# Factor Out The Shared Closure

An idea: let's factor out the shared closure and put it inside something (we will call it an object later).

``````type factor struct {
value int
}

func newFactor() factor {
return factor{value: 10}
}

func (f factor) add10(n int) int      { return n + f.value }
func (f factor) multiply10(n int) int { return n * f.value }
``````

Wow! An Object is very much like a bunch of functions with a shared closure!

# Last Bit, Mutation

``````type factor struct {
value int
}

func newFactor() factor {
return factor{value: 10}
}

func (f factor) add10(n int) int                           { return n + f.value }
func (f factor) multiply10(n int) int                      { return n * f.value }
func (f *factor) makeOtherMethodsMeaningless(newFactor int) { f.value = newFactor }
``````

Now we have a mutable closure, shared between a bunch of functions (now called methods).

# OOP and Functional Duality

OOP and Functional Programming "can" be seen as a dual. They represent the same thing, to a great extent and they try to provide tools to solve the same problem: composition.