Reflex - How Does It Work? (extended dance remix)

Reﬂex
How does it work?
Rocco Caputo – @rcaputo
YAPC::NA
Tuesday, 28 June 2011
Around Teatime

This talk
describes the
Github Version

Who Does He Think He Is?

• Rocco Caputo or “rcaputo” most places.
• http://search.cpan.org/~rcaputo/
• https://github.com/rcaputo
• http://twitter.com/rcaputo

The Other Committers
• Adam Kennedy • Jonathan Steinert

• Benjamin Smith • Larwan Berke

• Casey West • Martijn van Beers

• Chris Fedde • Matt Cashner

• Chris Williams • Matt Sickler

• David Davis • Perl Whore

• David Webb • Philip Gwyn

• Hinrik Örn Sigurðsson • Tom Feist

• jmadler • Yuval Kogman

The CPAN Authors
Alejandro Imass • Alessandro Ranellucci • Anatoly Sharifulin • Andrew A.
Chen • Andrew Hoying • Andrew Sterling Hanenkamp • Andrew V. Purshottam •
Andy Grundman • Artur Bergman • Benjamin Trott • Brendan Beveridge •
Chris Cobb • Chris Prather • Christian-Rolf Gruen • Curtis Hawthorne •
Daisuke Maki • Daisuke Murase • Damien Krotkine • Dan McCormick • David
Golden • David Snopek • Denis Pokataev • Dmitry Karasik • dmitry kim •
Eriam Schaffter • Eric Waters • Erick Calder • George Nistorica • Greg
Fast • Guillermo Roditi • Hans Dieter Pearcey • Ivan B. Serezhkin • J. J.
Merelo Guervos • Jan Henning Thorsen • Jason McManus • Jeff Bisbee • Jeff
Goff • Jerome Quelin • Johannes Plunien • Jonathan Ringstad • Jozef Kutej
• Justin Hunter • Kazuhiro Osawa • Kevin L. Esteb • Kirill Miazine •
Larry Shatzer Jr • Loic TROCHET • Marc Lehmann • Marc Mims • Mark A.
Hershberger • Mark McConnell • Mark Morgan • Markus Mueller • Matthew
O’Connor • Michael Ching • Michael R. Davis • Michael Schilli • Mike
Fletcher • Mike Schroeder • Mischa Spiegelmock • MOCK • MSERGEANT •
Nicholas Perez • Olivier ‘dolmen’ Mengue • Paul David Tinsley • Paul
Driver • Paul Evans • Paul G Webster • Paul Visscher • Pavel Boldin •
Pedro Melo • Peter Guzis • Przemyslaw Iskra • Rafael Kitover • Richard
Clamp • Rob Bloodgood • Rob Partington • Robert ‘phaylon’ Sedlacek •
Sawyer X • Scott Beck • Scott McCoy • Sean Egan • Sebastien Aperghis-
Tramoni • Sergey Kotenko • Sergey Skvortsov • Sjors Gielen • Stephen
Adkins • Steve James • Steve McNabb • Takeshi Miki • Tatsuhiko Miyagawa •
Thiago Berlitz Rondon • Tony Cook • Torsten Raudssus • wb@95700.net •
William Travis Holton • Yuji Suzuki • Yves Blusseau • Zoffix Znet

Reﬂex
What Is It?
YAPC::NA
Around Teatime

Reﬂex
What Isn’t It?
YAPC::NA
Around Teatime

What can’t you do with
a drunken sailor?

Reﬂex is an only
child waiting in
the park.

⃠
Reﬂex is an only
child waiting in
the park.

Reﬂex isn’t an
event loop.

CPAN
already has
too many
event
loops.

Event loops
are the means,
not the ends.

Reﬂex is
eventy without
so much loopy.

Nor is Reﬂex an
object system.

CPAN
already has
too many
object
systems.

But Why?!
“I am disappointed that after all this
time we have no consensus on how
to say in Perl ‘Class X has attribute
Y’ when so many other languages
have solutions that have freed their
users’ minds up to move on to
higher-level problems.”
— Peter Scott, on the Perl 5 Porters Mailing List

But Why?!

• Moose lets me solve higher-level problems.
• Moose has sufﬁcient adoption to survive.
• The Meta-Object Protocol is insanely useful.
• Moose will get better as native Perl OO
improves.

Reactive
Program Building
Blocks

Building
Blocks
Provided
by Moose

Plus a Reactor
provided by Your
Favorite Event
Loop

Like ORMs
hide SQL ORM

behind
objects... DB

Reﬂex
hides event
loops Reﬂex

behind The
Events

objects... Can

Reﬂex is Modern POE
• POE = Perl Object Environment
• Modern Perl objects are very different than
1998 Perl objects.
• POE has a lot of users.
• Start over with Reﬂex so POE remains
compatible.

Reﬂex
uniﬁes
eventy
interaction.

Rule 34 for Perl

If you can think
of it, CPAN has
a module for it.

TIMTOWTDI
If you can think
of it, CPAN has
2+ incompatible
modules for it...

TIMTOWTDI

... and someday
you’ll need to
use both at once.

TIMTOWTDI

• There’s more than one way to pass
events around.
• The “best” way... depends.
• Choosing poorly limits later options.
• Reﬂex supports any or all at once.

⁓1⁓
Objects must not
dictate callback
mechanisms.

⁓ 1.5 ⁓
Users deﬁne
how they
receive callbacks.

⁓2⁓
The base system
must support all
desired callback
types.

⁓3⁓
Reﬂex must do
just enough work
to be correct.

Reﬂex uniﬁes
eventy program
composition.

“How Eventy
Programs are
Put Together”

Static Composition

• Code is bolted together before running.
• Subclassing.
• Role composition.
• All pieces built and destroyed together.
• Most eventy abstractions ignore this.

Dynamic Composition

• Event watchers are created,
• related (has-a),
• communicated (with),
• and destructicated
• at run time.
• Lather, rinse, repeat until the owner ends.

Dynamic Lifetimes
• Object provides service to one owner.
• Object life is briefer than its owner.
• Object’s lifespan matches its owner.
• Good candidate for static composition.
• Object provides service to 2+ subscribers.
• Good candidate for breadboarding or
publish/subscribe.

Reﬂex
Embraces,
Extends and
Consumes Both

Reﬂex
How to Use It!
YAPC::NA
Around Teatime

Ye Olde Coderef
use Reflex::Interval;

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

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

Reflex->run_all();

Ye Olde Coderef

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

interval => 0.5,
);

Reflex->run_all();

Ye Olde Coderef

interval => 1,
);

• my $i_two = Reflex::Interval->new(
• interval => 0.5,
);

Reflex->run_all();

Ye Olde Coderef

interval => 1,
);

interval => 0.5,
• on_tick => sub { print "TICK TWO!!!n" },
);

Reflex->run_all();

Ye Olde Coderef
tick one...
TICK TWO!!!
TICK TWO!!!
tick one...
TICK TWO!!!
TICK TWO!!!
tick one...
TICK TWO!!!
TICK TWO!!!
^C

Ye Olde Coderef - The Good

• Quick and dead simple to use.
• Convenient and fast for small things.
• Parsimonious use of memory.

Ye Olde Coderef - The Bad

• Circular references and memory leaks—
unless you explicitly manage memory.
• Anti-pattern if done solely for speed...
• Implementation detail wags the dog.
• Giving up OO beneﬁts for speed.

Ye Olde Coderef - The Ugly
# A twisty maze of coderefs, all alike.

Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {
Watcher( sub {

Method Callbacks
{
• package TickingThing;
• use Moose; extends "Reflex::Base";

has ticker => (
isa => "Reflex::Interval", is => "rw",
default => sub {
my $self = shift();
Reflex::Interval->new(
interval => 1, on_tick => [ $self, "callback" ],
)
},
);

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

Thing->new()->run_all();

Method Callbacks
{
package TickingThing;
use Moose; extends "Reflex::Base";

• has ticker => (
• isa => "Reflex::Interval", is => "rw",
default => sub {
my $self = shift();
)
},
);

}


Method Callbacks
{

has ticker => (
default => sub {
my $self = shift();
• interval => 1, on_tick => [ $self, "callback" ],
)
},
);

}


Method Callbacks
{

has ticker => (
default => sub {
my $self = shift();
• interval => 1, on_tick => [ $self, "callback" ],
)
},
);

• sub callback { print "method got tick...n" }
}


Method Callbacks
method got tick...
method got tick...
method got tick...
method got tick...
method got tick...
method got tick...
method got tick...
method got tick...
method got tick...
method got tick...
^C

Methods – The Costs

• Verbose syntax.
• Perl OO is slower than code references
and closures.
• Perl OO requires memory.
• Moose uses memory, too.

Methods – The Beneﬁts
• Syntax gets sweeter.
• Object oriented design is cleaner and more
extensible.
• No twisty maze of nested code
references, all different.
• It’s all “standard” Perl and/or Moose.

Methods – The Future

• Avoiding ﬂexibility by design is a dead end.
• Speed and size improve over time.
• Perl may get its own MOP.
• Moose and Moose-alikes may converge as
Perl standardizes common features.

“But callbacks
suck!” you say?

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.

Promises
• Asynchronous event generator.
• Create it.
• Do other stuff while it’s working.
• Pick up the next result later.
• Blocks or returns “incomplete” if not done.
• Implementation decides which.
• Future release may let the caller decide.

Timer Promise (1 of 2)


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



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

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


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

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


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 promises.pl
• Before : 1295045065
Blocked 2 seconds.
• After two: 1295045067
After one: 1295045067

Eventy Timer Promise

% perl promises.pl
Before : 1295045065
• After two: 1295045067
Instant result.
• After one: 1295045067

When to Avoid! Shun!

• Only use Reﬂex’s promises for
asynchronous tasks that may need to wait.
• Synchronous generators and iterators are
more efﬁcient for computation.

“We were somewhere
around Asheville in the
heart of the Blue
Ridge Mountains when
the Moose began to
take hold.”

Method Callbacks
{

has ticker => (
default => sub {
my $self = shift();
)
},
);

}

• Thing->new()->run_all();

Subclassed Interval
{
• package TickingThing;
use Moose;
• extends "Reflex::Interval";

before on_tick => sub {
print "customized tick...n"
};
}

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

Subclassed Interval
{
use Moose;
extends "Reflex::Interval";

• before on_tick => sub {
• print "customized tick...n"
};
}

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

Subclassed Interval
{
use Moose;
extends "Reflex::Interval";

before on_tick => sub {
print "customized tick...n"
};
}

• TickingThing->new( interval => 1 )->run_all();

Roles

• They’re sticky.
• They’re delicious.
• They’re high in carbohydrate calories.
• They may contain bacon.

Reflex Roles

• Eventy features are implemented as roles.
• Consume them when appropriate.
• Each role has a corresponding class.
• Reflex::Interval is Reflex::Role::Interval.

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

• has interval => (
isa => "Num", is => "rw"
);

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

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

with "Reflex::Role::Interval" => {
• att_interval => "interval",
• att_auto_start => "auto_start",
• att_auto_repeat => "auto_repeat",
cb_tick => "on_tick",
method_start => "start",
method_stop => "stop",
method_repeat => "repeat",
};

sub on_tick {
my ($self, $args) = @_;
$self->emit(
event => "tick", args => $args
);
}

att_interval => "interval",
att_auto_start => "auto_start",
att_auto_repeat => "auto_repeat",
• cb_tick => "on_tick",
};

• sub on_tick {
• $self->emit(
• event => "tick", args => $args
);
}

• method_start => "start",
• method_stop => "stop",
• method_repeat => "repeat",
};

sub on_tick {
$self->emit(
event => "tick", args => $args
);
}


1;

Parameterized Roles

• Reﬂex uses role
parameters to wire
together code.

• MooseX::Role::
Parameterized rocks
for this.

Three Kinds of
Role Parameters

Attribute Parameters

• Name attributes in the consumer that
control role behavior.
• Begin with “att_”.

use Moose;

• has interval => ( isa => "Num", ... );
• has auto_start => ( isa => "Bool", ... );
...;

...,
};

use Moose;

has interval => ( isa => "Num", ... );
has auto_start => ( isa => "Bool", ... );
...;

...,
};

Callback Parameters

• Name consumer methods to call back
when things happen.
• Begin with “cb_”.
• These callbacks are simple, synchronous
method calls.

Callback Parameters
use Moose;
...;

...,
};

• sub on_tick {
my ($self, $args_hash) = @_;
...;
}

Method Parameters

• Roles may implement public API methods.
• Classes get to decide what they’re called.
• Begin with “method_”.

Method Parameters
{

...,
};
}

my $interval = Reflex::Interval->new();
• $interval->stop();
• $interval->start();

Awesome
but
tedious to
conﬁgure.

Dynamic Defaults

• Each role designates a primary attribute
parameter.
• Other parameter default values are based
on the primary parameter’s value.
• Avoids namespace clashes as an extension
of basic OO.

Primary Attribute
• att_interval => "watchdog",
...,
}

Role Parameter Default Name

method_start start_watchdog()

method_stop stop_watchdog()

cb_tick on_watchdog_tick()

Primary Attribute
• att_interval => "log_rotation",
...,
}

Role Parameter Default Name

method_start start_log_rotation()

method_stop stop_log_rotation()

cb_tick on_log_rotation_tick()

Primary Attribute
• att_auto_repeat => "auto_repeat",
};

Redundancy is a special case.
It overrides generally useful defaults.

Primary Attribute
};

Calls $self->on_tick()
... not $self->on_interval_tick()

Primary Attribute
};

Creates $interval->start()
... not $interval->start_interval()

Primary Attribute
};

Creates $interval->stop()
... not $interval->stop_interval()

Primary Attribute
};

Etc.

Expose Inner Workings
{
• package AnotherTickingThing;
• use Moose; extends "TickingThing";

has "+ticker" => (
handles => [ "interval" ],
);
}

my $thing = AnotherTickingThing->new();
$thing->interval(0.1);
$thing->run_all();

{
package AnotherTickingThing;
use Moose; extends "TickingThing";

• has "+ticker" => (
• handles => [ "interval" ],
• );
}

$thing->interval(0.1);
$thing->run_all();

{
package AnotherTickingThing;
use Moose; extends "TickingThing";

has "+ticker" => (
handles => [ "interval" ],
);
}

• $thing->interval(0.1);
$thing->run_all();

Replace Inner Workings
my $thing = TickingThing->new();

• $thing->ticker(
• Reflex::Interval->new(
• interval => 0.125,
on_tick => [ $thing, "callback" ],
)
);

$thing->run_all();


• my $thing = TickingThing->new(
ticker => Reflex::Interval->new(
interval => 0.125,
• on_tick => [ $thing, "callback" ],
)
);

Can’t use $thing like this.
It must be declared before it can be used.

• my $thing;
• $thing = TickingThing->new(
ticker => Reflex::Interval->new(
interval => 0.125,
)
);

Two statements.
Reference to $thing held inside $thing.

• my $thing = TickingThing->new();
• $thing->ticker(
interval => 0.125,
)
);

Dynamically replace it later.
Reference to $thing held inside $thing.

my $thing = TickingThing->new();

$thing->ticker(
interval => 0.125,
)
);

Either way, Reﬂex automatically weakens the
inner reference for you.

Override Attributes
{
• package FasterInterval;
• use Moose; extends "Reflex::Interval";

has "+interval" => (
default => 0.5,
);
}

FasterInterval->new()->run_all();

Override Attributes
{
package FasterInterval;
use Moose; extends "Reflex::Interval";

• has "+interval" => (
• default => 0.5,
);
}

FasterInterval->new()->run_all();

Override Attributes
{
package FasterInterval;
use Moose; extends "Reflex::Interval";

has "+interval" => (
default => 0.5,
);
}

• FasterInterval->new()->run_all();

What Can’t
Objects Do?
☺

Static Reﬂex
=
Moose

Dynamic
Reﬂex
=
Emit &
Watch

Crossing the
Barrier Between
Static & Dynamic
Interaction

Static to Dynamic
• Classes are built using static roles.
• Classes implement additional features.
• Callbacks within a class are synchronous.
• Classes emit dynamic messages.
• Dynamic object interaction is based on
watching for those messages.

Default Callback
};

• sub on_tick {
• $self->emit(
• event => "tick", args => $args
);
}

Dynamic back to Static?

Just Call
Stuff, Okay?

Trade Offs

• Dynamic object interaction is richer, more
fun, and often necessary.
• Beware of using dynamic messages solely
“for fun’s sake”.
• Static callbacks are more efﬁcient.

Emitting an Event
• package Moosian; use Moose;
• extends "Reflex::Base";

has name => ( is => "ro", isa => "Str" );

sub yip {
print(
$self->name(),
" says: Yip-yip-yip-yip..",
" uh-huh uh-huh..n"
);
$self->emit( event => "yipped" );
}

1;

Emitting an Event
package Moosian; use Moose;
extends "Reflex::Base";


• sub yip {
• print(
• $self->name(),
• " says: Yip-yip-yip-yip..",
• " uh-huh uh-huh..n"
• );
$self->emit( event => "yipped" );
}

1;

Emitting an Event
package Moosian; use Moose;


sub yip {
print(
$self->name(),
" says: Yip-yip-yip-yip..",
" uh-huh uh-huh..n"
);
• $self->emit( event => "yipped" );
}

1;

Emitting Events

• Objects emit() events as part of their
public interfaces.
• Events have no explicit destination.
• It’s up to users to watch() for events.

Watching Events

• my $bob = Moosian->new( name => "Bob" );
my $joe = Moosian->new( name => "Joe" );

• $bob->watch( $joe, "yipped", "yip" );
$joe->watch( $bob, "yipped", "yip" );

$bob->yip();

Reflex->run_all();

Watching Events

my $bob = Moosian->new( name => "Bob" );
• my $joe = Moosian->new( name => "Joe" );

$bob->watch( $joe, "yipped", "yip" );
• $joe->watch( $bob, "yipped", "yip" );

$bob->yip();

Reflex->run_all();

Watching Events

my $bob = Moosian->new( name => "Bob" );
my $joe = Moosian->new( name => "Joe" );

$bob->watch( $joe, "yipped", "yip" );
$joe->watch( $bob, "yipped", "yip" );

• $bob->yip();
• Reflex->run_all();

Moosian Dialog
Bob says: Yip-yip-yip-yip... uh-huh uh-huh..
Joe says: Yip-yip-yip-yip... uh-huh uh-huh..
^C

Inﬁnite Recursion OK
TIME RSS COMMAND
• 1:16.60 17940 perl moosians.pl

TIME RSS COMMAND
2:37.94 17940 perl moosians.pl

TIME RSS COMMAND

TIME RSS COMMAND

TIME RSS COMMAND

TIME RSS COMMAND

TIME RSS COMMAND

TIME RSS COMMAND

Simpliﬁed
Hierarchical
Watching

Hierarchical Watching?
• Most program
structure is
hierarchical.

• Trees of objects
that use other
objects.

• Parent objects
often need results
from children.

Callbacks
Discovered by
Name

Watched Attributes
• use Reflex::Trait::Watched qw(watches);
• watches clock => (
isa => "Reflex::Interval",
setup => sub {
Reflex::Interval->new(interval => 1)
},
);

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

Watched Attributes
use Reflex::Trait::Watched qw(watches);

watches clock => (
setup => sub {
},
);

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

Watched Attributes

• watches clock => (
setup => sub {
},
);


Watched Attributes

watches clock => (
• isa => "Reflex::Interval",
setup => sub {
},
);


Watched Attributes

• watches penguin => (
• isa => "Reflex::Bomb",
setup => sub { ... },
);

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

Watched Attributes

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

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

Watched Attributes


• watches watchdog => ( ... Interval ... );
• watches log_mark => ( ... Interval ... );
• sub on_watchdog_tick { ... }
• sub on_log_mark_tick { ... }

Two-Way Pipe Driver

• Bidirectionally stream data between two
ﬁle handles.
• Useful for proxies.

Two File Handles
• package Proxy;

use Moose;

• has client => (
• isa => "FileHandle",
is => "rw", required => 1 );

• has server => (
• isa => "FileHandle",
is => "rw", required => 1 );

• has active => (
• isa => "Bool",
is => "ro", default => 1 );

Reduced for Example

• use Reflex::Callbacks "make_null_handler";
• make_null_handler("on_client_closed");
• make_null_handler("on_client_error");
• make_null_handler("on_server_closed");
• make_null_handler("on_server_error");

From Client to Server

• with "Reflex::Role::Streaming" => {
att_active => "active",
• att_handle => "client",
};

sub on_client_data {
my ($self, $arg) = @_;
$self->put_server($arg->{data});
}

From Client to Server

with "Reflex::Role::Streaming" => {
att_handle => "client",
};

• sub on_client_data {
• $self->put_server($arg->{data});
}

From Server to Client

• with "Reflex::Role::Streaming" => {
• att_handle => "server",
};

sub on_server_data {
$self->put_client($arg->{data});
}

From Server to Client

with "Reflex::Role::Streaming" => {
att_handle => "server",
};

• sub on_server_data {
• $self->put_client($arg->{data});
}

Quote-Done-Unquote
• Not handling EOF (cb_closed).
• Not handling errors (cb_error).
• We’ll probably need separate “active” ﬂags
for client and server later.
• Flow-control for data rate mismatches?
• Etc.

Usage

# Assume we already have the sockets.

• my $p = Proxy->new(
• client => $client_socket,
• server => $server_socket,
);

# Do something else while it runs.

I Wrote What?
Reflex::Role::Writable
att_handle Reflex::Role::Reading
att_active att_handle
cb_ready cb_closed
method_pause cb_data
method_resume cb_error
method_start method_read Reflex::Role::Readable
Reflex::Role::Writing method_stop att_handle
att_handle att_active
cb_error cb_ready
method_put method_pause
method_flush Proxy method_resume
client method_stop
server
Reflex::Role::Streaming active Reflex::Role::Streaming
att_handle on_client_data att_handle
att_active on_client_closed att_active
cb_data on_client_error cb_data
cb_closed put_client cb_closed
cb_error stop_client cb_error
method_put on_server_data method_put
method_stop on_server_closed method_stop
on_server_error
Reflex::Role::Readable put_server
att_handle stop_server Reflex::Role::Writing
att_active att_handle
cb_ready cb_error
method_pause method_put
method_resume method_flush
Reflex::Role::Reading att_handle
method_stop
att_handle att_active
cb_closed cb_ready
cb_data method_pause
cb_error method_resume
method_read method_start
method_stop

Reflex::Role::Streaming
Reflex
The ability to....
Role
Reading ... read data from a non-blocking file handle.

Readable ... watch for data arriving on a file handle.

Writing ... buffer and/or write data to a NB file handle.

Writable ... watch a file handle for ability to write data.

Relax–It’s Just the Class

• That’s the Proxy class.
• All instances will share the same code.

Overkill? Dial it Back!

Roles let
programs pick
and mix what
they need.

Reflex::Role::InStreaming
Reflex::Role::InStreaming
att_handle
att_active
cb_data
cb_closed
cb_error
method_stop

Reflex::Role::Readable Reflex::Role::Reading
att_handle att_handle
att_active cb_closed
cb_ready cb_data
method_pause cb_error
method_resume method_read
method_stop

Reflex::Role::OutStreaming
Reflex::Role::OutStreaming
att_handle
att_active
cb_data
cb_closed
cb_error
method_put
method_stop

att_handle
Reflex::Role::Writing
att_active
att_handle
cb_ready
cb_error
method_pause
method_put
method_resume
method_flush
method_start
method_stop

Auto-Emit
Messages When
Attributes
Change

SmallTalk Messaging
• package EmittingCounter;
• use Reflex::Trait::EmitsOnChange qw(emits);
emits count => (
isa => "Int", default => 0
);

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

SmallTalk Messaging
package EmittingCounter;

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

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

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

Now Watch It
• use EmittingCounter;

• watches counter => (
• isa => "EmittingCounter",
setup => sub { EmittingCounter-> new() },
);

sub on_counter_count {
print "counter reached $args->{value}n";
}

Now Watch It
use EmittingCounter;

watches counter => (
isa => "EmittingCounter",
setup => sub { EmittingCounter-> new() },
);

• sub on_counter_count {
• print "counter reached $args->{value}n";
}

Reﬂex::Collection

• Manages objects that do
Reﬂex::Role::Collectible.
• Collectible objects are automatically
cleaned up when they stop.
• Great for create-and-forget things.

Echo Server (1 of 1)
{
• 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 {
$self->remember_client(
EchoStream->new( handle => $args->{socket} )
);
}
}

{
package TcpEchoServer; use Moose;
• extends "Reflex::Acceptor"; use EchoStream;

handles => {
}
);

sub on_accept {
);
}
}

{
extends "Reflex::Acceptor"; use EchoStream;
• use Reflex::Collection qw(has_many);

handles => {
}
);

sub on_accept {
);
}
}

{

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

sub on_accept {
);
}
}

{

handles => {
}
);

• sub on_accept {
• $self->remember_client(
• EchoStream->new( handle => $args->{socket} )
);
}
}

EchoStream (1 of 1)
• package EchoStream;
use Moose;
• extends "Reflex::Stream";

sub on_data {
$self->put($args->{data});
}

1;

EchoStream (1 of 1)
package EchoStream;
use Moose;
extends "Reflex::Stream";

• sub on_data {
• $self->put($args->{data});
}

1;

Beneﬁts of POE
• Mature and stable.
• Use any event loop you want.
• Hundreds of existing modules.
• Thousands of users.
• And you.
• Don’t rewrite everything at once.

POE Compatibility
• Migrate incrementally.
• Reflex can talk to POE modules.
• POE modules can talk to Reflex objects.
• “Separate but equal” is not enough.
• Static Reflex is faster than POE message
passing.
• Reflex eg directory contains examples.

“But is Reﬂex
Ready?”

40% Complete!
• Large swathes of design are stable.
• Documentation!
• ... which I broke preparing for this talk.
• Bugs!
• ... which I added preparing for this talk.
• Roadmap documented in the repository.

Help Make It Better
• http://github.com/rcaputo/reflex
• See the roadmap.
• #reflex on irc.perl.org
• poe-subscribe@perl.org
• Hackathon, BOF or hallway track.
• Use it, and complain... to me.
• Influence the project while it’s still plastic.

Contribute to a Project
• Nick Perez’s Reflex-based psgi server.
• Reflexive::Role::Collective
Interact with a collection of reflexive objects.
• Reflexive::Role::DataMover
Move data between two streams.
• Reflexive::Role::TCPServer
Become a fully featured TCP server.
• Reflexive::Stream::Filtering
Apply POE filters to Reflex streams.
• (Your Project Here)

Webliography
Drawing of Edgar Allan Self-Herding Cat
Poe.
ORM Diagram
“A Softer World” comic.
POE's users are
Wizard Moose outstanding in their ﬁelds.
Edgar Allan Bro Moose Antlers
Universum Promise Ring
Tiled Angry Moose The Watchers
Accidental Goatse A Fighter Jet Made of
(Unused) Biceps

Reflex - How Does It Work? (extended dance remix)

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (6)

Similaire à Reflex - How Does It Work? (extended dance remix)

Similaire à Reflex - How Does It Work? (extended dance remix) (20)

Dernier

Dernier (20)

Reflex - How Does It Work? (extended dance remix)