Stories from the other side

MageTitans Manchester, UK - #MageTitansMCR 2016-11-12 - twitter://@VinaiKopp

Stories from
the Other Side

Exploring OOP and
Functional Programming
(to become a better programmer)

Why am I interested in this?

Smart guys go FP (lambdalicious, phunkie)
The Little Schemer
Scala is the rage!

What is this, OOP + FP?
Where did these paradigms start?

The term "Object Oriented Programming"
was coined by Alan Kay

Original image by Marcin Wichary - Thanks!

Amongst many other achievements,
Alan Kay created Smalltalk

"OOP to me means only messaging,
local retention and protection
and hiding of state-process,
and extreme late-binding of all things"
It can be done in Smalltalk and in LISP."
~ Alan Kay

"It can be done in Smalltalk and in LISP."
wait... WHAT?

OOP in LISP?

((lambda (f)
(define pick
(lambda (n lat)
(cond
((zero? (sub1 n)) (car lat))
(else (pick (sub1 n) (cdr lat))))))
It's lists and recursion all the way down

How does OOP work with that?

What is OOP?

Is it about inheritance?

"OOP to me means only messaging,
local retention and protection
and hiding of state-process,
and extreme late-binding of all things"
~ Alan Kay

Kay doesn't mention inheritance.

Is OOP about classes?

Kay doesn't mention classes either.

If OOP is not about
classes or inheritance,
what is it about?

Lets start with
Messaging

I guess that means method calls.

In class based OOP,
the methods of a class deﬁne its
Interface.

Interface
==
Related Methods

Quite similar to
related Functions
within a Namespace

So OOP is about grouping methods together?

"... local retention and protection ..."
~ Alan Kay

Oh yeah, objects have states.

What is a state?

State in class based OOP:
class Foo
{
private static $class_state = 42;
private $instance_state = -0.2;
}

State in RL is more like
public function __construct(...)
{
$this->type = 'simple';
$this->customerSession = $customerSession;
$this->scopeConfig = $scopeConfig;
$this->counter = 0;
$this->id = $_REQUEST['id'];
$this->names = $db->getNames();
}

What properties do these examples of
state have?
public function __construct(...)
{
$this->scopeConfig = $scopeConfig;
$this->counter = 0;
}

A literal

A shared object

Literal zero
(but looks like that might change)
$this->counter = 0;

Global state

Stuff from the DB

Can we partition those examples?

1. State that is always the same
2. State that might change
(within the lifespan of the object)

State that might change:
→ Counter
→ Session
→ Filesystem / DB / Internet
→ Globals

Non-changing state
→ The Type ID
→ Application State
→ Conﬁguration

What can we do with
this information?

Pure
Functions!

Pure functions?

→ Don't cause any side effects
→ Given the same arguments
always return the same result

What are
side effects?

→ Changing state non-local to the
function scope
→ DB or Filesystem or Network access
→ Throwing Exceptions
→ Forking

No side effects
was one part.
What was the other?

Same Arguments
==>
Same Result

A function that always returns the same
result given the same arguments is called
Referentially Transparent

Referentially Transparent Functions
must not use state that might change!

Why should we care?

Beneﬁts
of Pure Functions!

→ Easier to think about
(reasonability)

→ Easier to break apart
(decomposability)

→ Easier to combine
(composability & reuseability)

→ Easier to show correctness
(testability)

→ Easier to parallelize
(threadability ;))

Mkay.
But what about the
changing things?

How can we deal with changing state?

We treat objects as snapshots of the
state of the world in one moment.

The state of the world in that
moment will never change.

If change occurs, it means now is a
different moment in time.

We can represent change in two ways:
→ by modifying the object
→ by creating a new instance

Immutability

For example, what happens when an
admin logs in?

$loggedInAdmin = $loggedOutAdmin->login();

public function login()
{
return new self($isLoggedIn = true);
}

But what if a method
needs the
"current instance"?

Either that object has to be recreated
with the current instance,
or the current instance has to be
passed as a method argument.

OOP style
$authorizationManager->hasAccess($dashboard, $loggedInAdmin);
$authorizationManager->hasAccess($dashboard, $loggedOutAdmin);

In FP
$has_access($dashboard, $loggedInAdmin);
$has_access($dashboard, $loggedOutAdmin);

There are more
parameters in RL!

Okay, lets reduce the argument count by
adding properties to the object.

$dashboardAuthorizationManager =
new class($authorizationManager, $dashboard) {
private $authorizationManager; private $page;
public function __construct($authorizationManager, $page)
{
$this->authorizationManager = $authorizationManager;
$this->page = $page;
}
public function hasAccess($admin)
{
return $this->authorizationManager
->hasAccess($this->page, $admin);
}
}

Only one argument left:
$pageAuthorizationManager->hasAccess($loggedInAdmin);
$pageAuthorizationManager->hasAccess($loggedOutAdmin);

How might that look like in FP?

$has_access_to_dashboard =
function ($admin) use ($dashboard, $has_access) {
return $has_access($dashboard, $admin);
}

$has_access_to_dashboard($loggedInAdmin);
$has_access_to_dashboard($loggedOutAdmin);

Can we remove all
arguments?

$loggedInAdminDashboardAuthorization =
new class($dashboardAuthorizationManager, $loggedInAdmin)
{
private $pageAuthorizationManager; private $admin;
public function __construct($pageAuthorizationManager, $admin)
{
$this->pageAuthorizationManager = $pageAuthorizationManager;
$this->admin = $admin;
}
public function hasAccess()
{
return $this->pageAuthorizationManager
->hasAccess($this->admin);
}
}

In FP:
$has_logged_in_admin_access_to_dashboard =
function () use ($has_access_to_dashboard, $admin) {
return $has_access_to_dashboard($admin);
}

We can bundle state
and functions
without classes!

We can bundle state
and process
without classes!

Look Ma,
OOP in PHP without
hands classes!

We have the choice:
→ pass state with method arguments
→ set state as object properties

The more volatile the object state,
the more often we need to
create new instances...

...if we want to have
Pure Functions.

Lesson from FP:
Distinguish between mutable and
immutable object properties.

"Mutable stateful objects are the new
spaghetti code"
~ Rich Hickey

Summary

Concepts from the FP languages can be
useful in OO PHP.

We can beneﬁt from designing our
OO code so it exhibits the properties of
pure functions.

We barely scratched the surface.

Don't be afraid of FP's mathematical
pattern names. It's still just code.

Building these slides I
learned something about OOP.
I hope you found it interesting, too!

(if (has-communication? you vinai)
(communicate you vinai)
(enjoy you remaining-agenda))

Stories from the other side

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (14)

Mais de vinaikopp

Mais de vinaikopp (20)

Último

Último (20)

Stories from the other side