Event Driven
Applications
Wrangle Cross-Cutting
Concerns

Chris Saylor
Lead Engineer
@cjsaylor
150+ countries
14 million weekly class
participants
15 million monthly pageviews
47 million monthly service
requests
Zumba Fitness

What to expect
What are cross-cutting concerns?
Origins from Observer pattern
Asynchronous vs Synchronous
Logic abstraction
Demo
Events in the wild
Advantages and drawbacks
Futher considerations

What are cross-cutting
concerns?

Cross-cutting concerns are parts of a program that
rely on or must affect many other parts of the
system.
Source: Wikipedia.org

Examples of cross-cutting concerns
Logging
Caching
Product feature interaction
Monitoring
Record audit trail
State Management

What are the risks of cross cutting
concerns?
Coupling systems too tightly (aka "Tangling")
Lots of code duplications (aka "Scattering")

Single Responsibility Principle
If a class and its services should be responsible for
one thing, how do we deal with unrelated business
rules that must be addressed by that class?

Origins from Observer pattern

Observer Pattern
The root of Event Driven Applications began with the observer
pattern which tracks the state of a subject by attaching observers to
the subject so that when it changes, all observers are notified.

SplObserver
The interface is a standard lib to implement this
pattern.
SplObserver
An SplSubject object attaches the observer.
The SplSubject then calls an update on the observer when notifying
the registered observers.

Asynchronous vs Synchronous

App event in javascript
Syncronous in order of execution
Asyncronous in order of completion
$('p')
.on('click', function() {
(function() {
console.log('first?');
}());
})
.on('click', function() {
(function() {
console.log('second?');
}());
});

App event in PHP
Syncronous
Predictable order of execution and completion
<?php
$event
->on('event1', function() {
echo "First!";
})
->on('event1', function() {
echo "Second."
});

Logic abstraction

Separation of Concerns
Use synchronous events to separate chunks of business logic away
from core functionality
Provides for modularity
Allow for unit testing listeners
Multiple messages - multiple listeners

Example Before
<?php
function login($username, $password) {
try {
// get user from db
$user = Repository::get($username, $password);
// Check if an admin
if ($user->role->admin) {
$_SESSION['admin'] = true;
}
// Log user's login
$user->updateLastLogin(time());
Repository::saveUser($user);
} catch (Exception $e) {
return false;
}
return true;
}

Example After
<?php
function login($username, $password) {
try {
// get user from db
$user = Repository::get($username, $password);
// Fire post login event
$event::trigger('afterLogin', compact('user'));
} catch (Exception $e) {
return false;
}
return true;
<?php
$event::listen('afterLogin', function($event) {
if ($event->data['user']->role->admin) {
$_SESSION['admin'] = true
}
});
$event::listen('afterLogin', function($event) {
$event->data['user']->updateLastLogin(time());
Repository::saveUser($event->data['user']);
});

Demo
https://github.com/cjsaylor/event-driven-apps-demo
Branch: cart-demo (cart-demo-event)

Events in the wild

CakePHP
Controllers have beforeFilter, beforeRender, and components with
similar callbacks
Models have behaviors with before find/save
Exposed event library

Symfony 2
can be used as a standalone event library.
Can be easily incorporated via Composer
EventDispatcher

Zend
can be used to create events and listeners of said
events
Can be extracted from Zend, but not as easily as Symfony 2.
EventManagers

Many others...
Guzzle
Magento
Lithium

Advantages and Drawbacks

Decouple Code
Advantage:
Modular design can reduce core functionality bugs when modifying
modules.
Allows for open frameworks to allow third parties to implement
custom solutions without modifying core files.
Disadvantage:
Code is harder to follow and needs good organizational
management.
Documentation of what events will be called when is almost a
must.

Plugin Architecture
Advantage:
Enable or disable plugins on the fly.
Essential for open source targeting developers to implement.
Disadvantage:
No dependencies should exist be between plugins.

Testing
Advantage:
Test the listeners separate from the core functionality.
Execute listeners from core test cases via external event triggers.
Mock event callbacks to test event trigger placement.
Disadvantage:
Multiple event bindings in test suites results in undesired event
triggers.
Unbinding specific event callbacks can be difficult to do.

Further considerations

Synchronous or
Asynchronous?
Make a judgment on whether an event listener should process it now
or post-request process with a call to a message queue.

Events and Variable Reference
Using an object for passage into the event so all event handlers have
access to the same data.

Specialization
Is the logic I'm trying to abstract into an event worth doing so? Would
this logic best be housed in the core logic?

Further Reading
Using application events to hook in plugins
Decoupling applications with domain events
Domain Events

Thank you
Get this presentation on slideshare:
http://www.slideshare.com/cjsaylor/event-driven-application