Reflex - How does it work?

Reﬂex
How does it work?
Rocco Caputo – @rcaputo
Orlando Perl Workshop
Saturday, 15 January 2011
Around Noon

Reﬂex
What Is It?
Rocco Caputo – @rcaputo
Orlando Perl Workshop
Saturday, 15 January 2011
Around Noon

What’s Reﬂex?!

• Library of roles that process eventy stuff—
timers, I/O notiﬁcations, signals, etc.
• Eventy class library built with those roles.

Reﬂex Roles–Brieﬂy
package AsyncConsole;
use Moose; extends 'Reflex::Base';

has stdin => (
is => 'rw',
isa => 'FileHandle',
required => 1,
);

with 'Reflex::Role::Readable' => {
handle => 'stdin',
cb_ready => 'get_keystroke',
};

sub get_keystroke { ... }

Reﬂex Roles?
package Console;

has stdout => (
is => 'rw',
isa => 'FileHandle',
required => 1,
);

with 'Reflex::Role::Readable' => {
handle => 'stdin',
cb_ready => 'get_keystroke',
};

sub get_keystroke { ... }

Sufﬁciently
Advanced
Technology

“Sufﬁciently
Advanced”
=
We Don’t
Know Yet

Learn Just
Enough Magic in
20 Minutes to
Harm Yourself

Learn Just
Enough Magic in
18 Minutes to
Harm Yourself

Dynamic Composition
• Objects are created,
• related,
• communicated (with),
• and destructicated
• at run time.
• Lather, rinse, repeat until the program ends.

Static Composition

• Code is bolted together before running.
• It stays that way “forever”.

• Subclassing.
• Moose roles.

Ye Olde Coderef
use Reflex::Interval;

my $i = Reflex::Interval->new(
interval => 1,
on_tick => sub { print "tick...n" },
);

$i->run_all();

Ye Olde Coderef

tick...
tick...
tick...
^C

Ye Olde Coderef
• Quick and dead simple to use.
• Closure tricks for convenience and speed.

• Closures can’t use OO to extend or
override event handlers.
• Uses circular references—memory leakage
if you’re not careful.

Methods
has ticker => (
isa => 'Reflex::Interval', is => 'rw' );

sub BUILD {
my $self = shift;
$self->ticker(
Reflex::Interval->new(
interval => 1,
on_tick => cb_method($self, "callback"),
)
);
}

sub callback { print "tick...n" }

Methods
• Cleaner object oriented design.
• Callbacks can use every Moose trick in the
book.

• Requires more forethought.
• Perl & Moose OO less performant than
anonymous subroutines & closures.

Callbacks
Discovered
Automatically

Observed Attributes
use Reflex::Trait::Observed qw(observes);

observes clock => (
isa => 'Reflex::Interval',
setup => sub {
Reflex::Interval->new(interval => 1)
},
);

sub on_clock_tick { print "tick...n" }

Observed Attributes

observes penguin => (
isa => 'Reflex::Bomb',
setup => sub { ... },
);

sub on_penguin_tick { ... }
sub on_penguin_stop { ... }
sub on_penguin_explode { ... }

Observed Attributes


observes watchdog => ( ... Interval ... );
observes log_mark => ( ... Interval ... );

sub on_watchdog_tick { ... }
sub on_log_mark_tick { ... }

What’s a Promise?
“an object that acts as a proxy
for a result that is initially not
known, usually because the
computation of its value has
not yet completed.”
— Wikipedia

What’s a Promise?

Blah blah blah.

What’s a Promise?
• Asynchronous object.
• Create it.
• Do other stuff while it runs.
• Pick up the result later.
• Blocks or returns “incomplete” if not done.
• Other stuff runs while it blocks.

Timer Promise (1 of 2)
use Reflex::Interval;

my $one = Reflex::Interval->new(
interval => 1
);

my $two = Reflex::Interval->new(
interval => 2
);

Timer Promise (2 of 2)

print "Before : ", time(), "n";

my $event = $two->next();
print "After two: ", time(), "n";

$event = $one->next();
print "After one: ", time(), "n";

Eventy Timer Promise

% perl this-time-for-sure.pl
Before : 1295045065
After two: 1295045067
After one: 1295045067

Eventy Subclassing
{
package MyTimer;
use Moose;
extends 'Reflex::Interval';

before on_tick => sub { say "tick..." };
}

MyTimer->new( interval => 1 )->run_all();

Eventy Subclassing

tick...
tick...
tick...
^C

Reﬂex::Interval (1 of 3)
package Reflex::Interval;

has interval => (
isa => 'Num', is => 'ro'
);

has auto_repeat => (
isa => 'Bool', is => 'ro', default => 1
);

has auto_start => (
isa => 'Bool', is => 'ro', default => 1
);

with 'Reflex::Role::Interval' => {
interval => "interval",
auto_start => "auto_start",
auto_repeat => "auto_repeat",
cb_tick => "on_tick",
ev_tick => "tick",
method_start => "start",
method_stop => "stop",
method_repeat => "repeat",
};


1;

Reflex Roles
• Reflex eventiness implemented with roles.
• Timers, I/O, signals, etc.
• Roles are reified by simple classes.
• Reflex::Interval is Reflex::Role::Interval.
• Larger roles comprise simpler ones.
• It’s all Mooses, all the way down.

Parameterized Roles

• MooseX::Role::Parameterized rocks.
• Parameters customize roles—ﬁll in the
blanks like templates.
• Reﬂex uses it like breadboarding with
Moose.

They’re Tedious
to Conﬁgure

Smart Defaults

• A primary attribute identiﬁes the role.
• Default parameters are named after that
attribute.
• Roles avoid conﬂicts by default.
• Without tediously supplying all parameters.

Key Attribute
interval => "watchdog",
}

Role Parameter Default Name
method_start start_watchdog()

method_stop stop_watchdog()

cb_tick on_watchdog_tick()

ev_tick watchdog_tick

Key Attribute
interval => "logmark",
}

Role Parameter Default Name
method_start start_logmark()

method_stop stop_logmark()

cb_tick on_logmark_tick()

ev_tick logmark_tick

One Class
Role Five Six
Uses

Smalltalk Messaging
• Reﬂex::Trait::EmitsOnChange
• Emits an event when an attribute changes.
use Reflex::Trait::EmitsOnChange qw(emits);

emits count => (
isa => 'Int', default => 0
);

sub on_ticker_tick {
my $self = shift;
$self->count($self->count() + 1);
}

Smalltalk Messaging

use Reflex::Trait::EmitsOnChange qw(emits);

emits count => (
isa => 'Int', default => 0
);

sub on_ticker_tick {
my $self = shift;
$self->count($self->count() + 1);
}

Reﬂex::Collection

• Manages Reﬂex::Role::Collectible objects.
• Removes them as they stop.
• Great for holding autonomous things.

Reﬂex::Collection
{
package TcpEchoServer; use Moose;
extends 'Reflex::Acceptor'; use EchoStream;
use Reflex::Collection qw(has_many);

has_many clients => (
handles => { remember_client => "remember" } );

sub on_accept {
my ($self, $args) = @_;
$self->remember_client(
EchoStream->new( handle => $args->{socket} )
);
}
}

EchoStream
package EchoStream;
use Moose;
extends 'Reflex::Stream';

sub on_data {
my ($self, $args) = @_;
$self->put($args->{data});
}

1;

Reﬂex is Newish

• Large swathes of design are stable.
• Details need to be ironed out.
• Will happen faster if you use it.
• Help me ﬁnd the edge cases.

How To Help
• http://github.com/rcaputo/reﬂex
• See docs/TODO.otl
• #reﬂex on irc.perl.org
• poe-subscribe@perl.org
• Hackathon?
• Hire someone to use it on your project.

Contribute to a Project
• Nick Perez’s Reflex-based psgi server.
• Reflexive::Stream::Filtering
• Attach POE filters to Reflex streams.
• Reflexive::Role::TCPServer
• Consumable full-featured TCP server.
• (Your Project Here)

Reflex - How does it work?

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Reflex - How does it work? (20)

Recently uploaded (20)

Reflex - How does it work?

Editor's Notes