stories from the other side

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

Stories fromthe Other Side

Exploring OOP andFunctional Programming(to become a better programmer)

Why am I interested in this?

Smart guys go FP (lambdalicious, phunkie)The Little SchemerScala 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 aboutclasses 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 define its

Interface.

Interface==

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

Quite similar to

related Functionswithin 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 likepublic 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->type = 'simple'; $this->customerSession = $customerSession; $this->scopeConfig = $scopeConfig; $this->counter = 0; $this->id = $_REQUEST['id']; $this->names = $db->getNames();}

A literal $this->type = 'simple';

A shared object $this->customerSession = $customerSession;

Literal zero(but looks like that might change)

$this->counter = 0;

Global state $this->id = $_REQUEST['id'];

Stuff from the DB $this->names = $db->getNames();

Can we partition those examples?

1. State that is always the same2. 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→ Configuration

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 areside effects?

→ Changing state non-local to the function scope

→ DB or Filesystem or Network access→ Throwing Exceptions

→ Forking

No side effectswas one part.

What was the other?MageTitans Manchester, UK - #MageTitansMCR 2016-11-12 - twitter://@VinaiKopp

Same Arguments==>

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

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?

Benefitsof 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 ;))

But what about the changing things?

How can we deal with changing state?

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

The state of the world in thatmoment 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

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

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 recreatedwith the current instance,

or the current instance has to bepassed 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 stateand functions

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

We can bundle stateand process

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

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 havePure Functions.

Lesson from FP:Distinguish between mutable and

immutable object properties.

"Mutable stateful objects are the new spaghetti code"

~ Rich Hickey

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

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

We can benefit from designing ourOO 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 Ilearned 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

Software

bliss and other stories

security…and other horror stories

the darling and other stories

2008 version unit three...

cinder ella and other stories

author title - azimpremjifoundation.org of resources... ·...

dealing with interferon side effects patient stories

musikalische leitung: reto güdel west side stories

parrot's training and other stories

moon-face and other stories

the other side

j class - hollywood foundry s/sem j class.pdffigure figure...

doll's house and other stories prl4 - k. mansfieldoll's...

find other stories - marxists

wine side stories

laramie & albany county, wyoming west side stories

the incident & other stories

lost love and other stories

crackling mountain and other stories

forty fortunes and other stories