狠狠撸

ASYNCHRONOUS
PROGRAMMING
FTW!
(SAWYER X)

DOES THIS SOUND FAMILIAR?
"Hi"
"Hi, dad"
"Got a minute?"
"Yes"
"I'm looking for a movie
Where do I start?"
"Go to the cinema website"
"What's the address?"
"www.whatchamacallit.whatever"
"Just a sec..."

"Well?"
"Ah! It loaded! What now?"
"Click on new movies"
"OK..."
........
"Well?"
"Loading"
*sounds of clicks*

"OK, now what?"
"Find a movie you want"
"Then what?"
"Click on it, you'll have instructions"
* eternity passes by *
"WELL?!?"
"Just a sec... it's loading..."
/me shoots myself

ILLUSTRATED
(USING WWW::MECHANIZE)
$eh>e(cnm_r)
mc颅gt$ieaul途
i听听mc颅sces){
f($eh>ucs听听
听听$eh>lc(NwMve'途
听听mc颅cik'e听ois)
听听i听听mc颅sces){
听听f($eh>ucs听听
听听听听m听mve听听mc颅fn_nus..
听听听听y@ois=$eh>idipt(.)
听听}
听听
}

LET'S TRY THIS AGAIN...
"Hi"
"Hi, dad"
"Got a minute?"
"Yes"
"I'm looking for a movie
What should I do?"
"Go to this website, click on new movies
Then pick a movie, and click on it"
"Thank you"
"You're welcome"

CALLBACKS
Reference to a code
Passed as an argument
Can be called by some other code
sbtysmtig{
u听r_oehn听
听听m听ipt听听hf途
听听y$nu听=sit
听听m听c听听听听hf途
听听y$b听听=sit
听听m听rsl听听oeoeain$nu)
听听y$eut=sm_prto(ipt途

听听i听听rsl颅{sau'听q'K听听
听听f($eut>'tts}e听O'){
听听听听$b>听rsl颅{cnet})
听听听听c颅($eut>'otn'听途
听听}
听听
}

tysmtig听sm听admipt,sb{
r_oehn("oerno听nu"听u听
听听m听cnet=sit
听听y$otn听听hf途
听听sy"ucsflrqetsy听cnet"
听听a听Scesu听eus听as$otn!途
})
听途

ILLUSTRATED, ASYNC
(USING WWW::MECHANIZE)
$eh>e($ieaul听u听
mc颅gt听cnm_r,sb{
听听$eh>lc('e听ois,sb{
听听mc颅cik听NwMve'听u听
听听听听$eh>idipt(..听u听听y@ois=@听听
听听听听mc颅fn_nus听.,sb{m听mve听听_})
听听})
听听听途
})
听途

WHY IS THIS USEFUL?
Allow others to decide if something is good or not

m听jn听听uo>e(
y$uo=Jn颅nw
听听hss听>[w11112222]
听听ot听=听q<...听...>,
听听cek听>{
听听hcs=听
听听听听Fig=听
听听听听Pn听>{
听听听听听听o_ucs听>sb{
听听听听听听nsces=听u听
听听听听听听听听m听听jn,$ot听dt听听听_
听听听听听听听听y($uo听hs,$aa)=@途
听听听听听听听听m听听i,$os听ag)=$uo>nlz_igrsl(
听听听听听听听听y($p听ls,$v听听听jn颅aayepn_eut
听听听听听听听听听听$aa>'ter}
听听听听听听听听听听dt颅{sdr',
听听听听听听听听)
听听听听听听听听途

听听听听听听听听$ef>e_ot听hs,$v听途
听听听听听听听听sl颅sths($ot听ag)
听听听听听听}
听听听听听听,

听听听听听听o_al=听u听
听听听听听听nfi听>sb{
听听听听听听听听m听听jn,$ot)=@途
听听听听听听听听y($uo听hs听听听_

听听听听听听听听$ef>eeehs(hs)
听听听听听听听听sl颅dlt_ot$ot途
听听听听听听}
听听听听听听,
听听听听}
听听听听
听听}
听听
)途

WHY IS THIS USEFUL?
Allow easy stepping

Algorithm::Diff::Callback
ueAgrtm:if:alakq<ifary听ifhse>
s听loih:Df:Clbc听wdf_rasdf_ahs途

df_ras
ifary(
听听odfml_ebr,
听听@l_aiymmes
听听nwfml_ebr,
听听@e_aiymmes
听听sb{pit'ap听oha听bu听,sit}
听听u听听rn听Hpyt听eraot'听hf听,
听听sb{pit'or听oha听bu听,sit}
听听u听听rn听Sryt听eraot'听hf听,
)途

df_ahs
ifhse(
听听oddtis
听听%l_eal,
听听nwdtis
听听%e_eal,
听听sb{sy'ot'听听hf听,
听听u听听a听Ls听,听sit}
听听sb{sy'and'听hf听,
听听u听听a听Gie听,sit}
听听sb{
听听u听
听听听听m听听ky听bfr,$fe听听听_
听听听听y($e,$eoe听atr)=@途
听听听听sy"kycagdfo听bfr听o$fe"
听听听听a听$e听hne听rm$eoet听atr途
听听}
听听,
)途

WHY IS THIS USEFUL?
Allow easy stepping
Allow control by other process (a type of IOC)
Allow asynchronous code

THE EVENT LOOP
Create loop
Register events
Run them
Let the user keep registering new events

m听eet听听..途
y%vns=(.)

wie(){
hl听1听
听听frahm听eet(ky听eet听听
听听oec听y$vn听听es%vns){
听听听听$vn颅(途
听听听听eet>)
听听}
听听
}

m听eet途%vns=(.)
y%vns听eet听听..途

wie(){
hl听1听
听听听听$vn颅(途
听听听听eet>)
听听}
听听
}

wie(){
hl听1听
听听听听i听听eet{eet{tm'听=tm听听
听听听听f($vns$vn}'ie}<听ie){
听听听听听听$vns$vn}'oe}>)
听听听听听听eet{eet{cd'颅(途
听听听听}
听听听听
听听}
听听
}

sbadeet{
u听d_vn听
听听m听听tm,$oe)=@途
听听y($ie听cd听听听_
听听$vns$d{tm'听听tm途
听听eet{i}'ie}=$ie
听听$vns$d{cd'听听cd途
听听eet{i}'oe}=$oe
听听$d+
听听i+途
}

EVENT TYPES
Timers (one-time, recurring, sleep replacement)
I/O (input output, including networking)

FUCK TALK
LET'S GO PROGRAMMING

IO::ASYNC
Loop interface: IO::Async::Loop
You can connect to hosts using it
You can add listeners to it (handles, sockets, etc.)
Explicitly call "run" when ready

ueI:Ayc:tem
s听O:sn:Sra途
ueI:Ayc:op
s听O:sn:Lo途
听
m听lo听听O:sn:Lo颅nw
y$op=I:Ayc:op>e途

$op>onc(
lo颅cnet
听听hs听听听=听sm.te.ot,
听听ot听听听>"oeohrhs"
听听srie听=听24,
听听evc听听>135
听听sctp听=听sra'
听听okye听>'tem,
听听
听听o_tem=听u听听.听,
听听nsra听>sb{..}
听听
听听o_eov_ro听>sb{
听听nrsleerr=听u听
听听听听de"antrsle颅$[1"
听听听听i听Cno听eov听听_颅]
听听}
听听,

听听o_onc_ro听>sb{
听听ncneterr=听u听
听听听听de"antcnet颅$[]fie听_颅]
听听听听i听Cno听onc听听_0听ald$[1"
听听}
听听,
)途

$op>u途
lo颅rn

o_tem=听u听
nsra听>sb{
听听m听听sra听听听_
听听y($tem)=@途

听听$tem>ofgr(
听听sra颅cniue
听听听听o_ed=听u听
听听听听nra听>sb{
听听听听听听m听听sl,$ufe,$o听听听_
听听听听听听y($ef听bfrf听ef)=@途

听听听听听听wie听{bfrf听~s^.)/){
听听听听听听hl($$ufe}=听/(*n/听听
听听听听听听听听sy"eevdaln听1途
听听听听听听听听a听Rcie听听ie$"
听听听听听听}
听听听听听听

听听听听听听rtr听途
听听听听听听eun0
听听听听}
听听听听
听听)
听听途

听听$tem>rt(A听nta听iehr'途
听听sra颅wie'niiilln听ee)

听听$op>d(sra)
听听lo颅ad$tem途
}

ANOTHER EXAMPLE
$pr听MO:sn听Me:Ayc:TP颅听
听el颅I:Ayc颅Nt:sn:HT听E'
听听I:Ayc>d(m听ht听听e:Ayc:TP>e听途
听听O:sn颅ad听y$tp=Nt:sn:HT颅nw)
听听syfrI:Ayc>wi_l(mp{$tp>e(_听听)
听听a听o听O:sn颅aatal听a听听ht颅gt$)}听
'>ls颅fUL.x
听听ito颅Rstt

Oh hai parallel HTTP GET!

POE
Loop interface: POE::Kernel
Runs "sessions" (POE::Session)
Each session is a context of events
Each session has an ID and heap
Call events in a current or different session
Explicitly call POE::Kernel->run when ready

POE
uePE听#At颅nldsPE:enladPE:eso.
s听O途听听uoicue听O:Kre听n听O:Ssin

#..dfn听alak听us(etsie听.
听.听eieclbcssb听nx听ld)..

fr(.1){
o听1.0听
听听PE:eso颅cet(
听听O:Ssin>rae
听听听听iln_tts=听
听听听听niesae听>{
听听听听听听_tr听听=听&ade_tr,
听听听听听听sat听听>hnlrsat
听听听听听听iceet=听&ade_nrmn,
听听听听听听nrmn听>hnlriceet
听听听听听听_tp听听=听&ade_tp
听听听听听听so听听听>hnlrso,
听听听听}
听听听听
听听)
听听途
}

PE:enl>u(途
O:Kre颅rn)

sbhnlrsat{
u听ade_tr听
听m听听kre,$ep听ssin)=@[KRE,HA,SSIN]
听y($enl听ha,$eso听听听_听ENL听EP听ESO听途
听sy"eso听,$eso颅I,"hssatd途
听a听Ssin"听ssin>D听听a听tre"
听$ep>'on'听听途
听ha颅{cut}=0
听$enl>il(iceet)
听kre颅yed'nrmn'途
}

sbhnlriceet{
u听ade_nrmn听
听sy"eso听,$eso颅I,"cutdt听,+$ep>'on'途
听a听Ssin"听ssin>D听听one听o"听+ha颅{cut}
听$enl>il(iceet)i听ha颅{cut}<1途
听kre颅yed'nrmn'听f$ep>'on'听听0
}

sbhnlrso听
u听ade_tp{
听sy"eso听,$[ESO]>D听听a听tpe"
听a听Ssin"听_SSIN颅I,"hssopd途
}

sbhnlrsat{
u听ade_tr听
听sy"eso听,$eso颅I,"hssatd途
听a听Ssin"听ssin>D听听a听tre"
听$ep>'on'听听途
听ha颅{cut}=0
听$enl>il(iceet)
听kre颅yed'nrmn'途
}
sbhnlriceet{
u听ade_nrmn听
听sy"eso听,$eso颅I,"cutdt听,+$ep>'on'途
听a听Ssin"听ssin>D听听one听o"听+ha颅{cut}
听$enl>il(iceet)i听ha颅{cut}<1途
听kre颅yed'nrmn'听f$ep>'on'听听0
}
sbhnlrso听
u听ade_tp{
听sy"eso听,$[ESO]>D听听a听tpe.n途
听a听Ssin"听_SSIN颅I,"hssopd"
}
fr(.1){
o听1.0听
听听PE:eso颅cet(
听听O:Ssin>rae
听听听听听听_tr听听=听&ade_tr,
听听听听听听sat听听>hnlrsat
听听听听听听iceet=听&ade_nrmn,
听听听听听听nrmn听>hnlriceet
听听听听听听_tp听听=听&ade_tp
听听听听听听so听听听>hnlrso,
听听听听}
听听听听
听听)
听听途
}
PE:enl>u(途
O:Kre颅rn)

MORE CONDENSED
uePE
s听O途

fr(.1){
o听1.0听
听听m听cut=0
听听y$on听听途

听听PE:eso颅cet(
听听O:Ssin>rae
听听听听听听_tr听听=听u听
听听听听听听sat听听>sb{
听听听听听听听听sy"eso听,$[ESO]>D听听a听tre"
听听听听听听听听a听Ssin"听_SSIN颅I,"hssatd途
听听听听听听听听PE:enl>il(iceet)
听听听听听听听听O:Kre颅yed'nrmn'途
听听听听听听}
听听听听听听,
听听听听听听iceet=听u听
听听听听听听nrmn听>sb{
听听听听听听听听PE:enl>il(iceet)i听+cut<1途
听听听听听听听听O:Kre颅yed'nrmn'听f+$on听听0
听听听听听听听听sy"eso听,$[ESO]>D听听one听o$on"
听听听听听听听听a听Ssin"听_SSIN颅I,"cutdt听cut途
听听听听听听}
听听听听听听,
听听听听听听_tp听听=听u听
听听听听听听so听听听>sb{
听听听听听听听听sy"eso听,$[ESO]>D听听a听tpe"
听听听听听听听听a听Ssin"听_SSIN颅I,"hssopd途
听听听听听听}
听听听听听听,
听听听听}
听听听听
听听)
听听途
}

PE:enl>u(途
O:Kre颅rn)

REFLEX
Written by author of POE
"How POE would be written if I had Moose back then"
Stresses composability, reusability
Includes plenty of additional roles

USING MOOSE
{
听听pcaeAp
听听akg听p途
听听ueMoe
听听s听os途
听听etns'elx:ae途
听听xed听Rfe:Bs'
听听ueRfe:Itra途
听听s听elx:nevl
听听ueRfe:Tat:ace听wths途
听听s听elx:ri:Wthd'ace'
听
听听wthstce听>(
听听ace听ikr=听
听听听听ia听=听Rfe:Itra'
听听听听s听听>'elx:nevl,
听听听听stp=听听nevl=听,at_eet=听听,
听听听听eu听>{itra听>1听uorpa听>1}
听听)
听听途
听
听听sbo_ikrtc听
听听u听ntce_ik{
听听听听sy'ika听,saa(oatm)听..途
听听听听a听tc听t'听clrlclie,'.'
听听}
听听
}
听
ei听p颅nw)>u_l(途
xtAp>e(颅rnal)

COMPLEX? TRY THIS...
ueRfe:Itra途
s听elx:nevl
听
m听t=Rfe:Itra颅nw
y$听听elx:nevl>e(
听听itra听听=听,
听听nevl听听>1
听听at_eet=听,
听听uorpa听>1
听听o_ik听听=听u听听a听tmrtce'}
听听ntc听听听>sb{sy'ie听ikd听,
)途
听
$颅rnal)
t>u_l(途

ANYEVENT
AnyEvent is very thin and very fast
Was written to support as many loops as possible
... that conform to the author's rules of compatibility
Does not use a loop handler, simply runs
Does use conditional variables
Has AE for faster performance

ueAyvn途
s听nEet
m听cut=0
y$on听听途
m听c听听=Ayvn颅cnvr
y$v听听听nEet>oda途
m听t听听=Ayvn颅tmr
y$听听听听nEet>ie(
听听atr听听>2
听听fe听听=听,
听听itra听>06
听听nevl=听.,
听听c听听听听>sb{
听听b听听听=听u听
听听听听sy'h听iei听o:'听nEet>o途
听听听听a听Tetm听snw听,Ayvn颅nw
听听听听+$on听=1听n听c颅sn途
听听听听+cut=听0ad$v>ed
听听}
听听,
)途

$v>ev
c颅rc途

m听w听w=Ayvn颅i(
y$途$听听nEet>o
听听f听听>SDN
听听h听=听*TI,
听听pl听>''
听听ol=听r,
听听c听听>sb{
听听b听=听u听
听听听听cop(m听ipt=听途
听听听听hm听听y$nu听听)
听听听听sy"ed听ipt途
听听听听a听ra:$nu"
听听听听udf$途
听听听听ne听w
听听}
听听,
)途

USAGES OF ASYNCHRONOUS CODE
GUI
Services (HTTP/SMTP/etc.)
Performance
Off-loading tasks

狠狠撸

Asynchronous programming FTW!

Recommended

More Related Content

What's hot (12)

Similar to Asynchronous programming FTW! (6)

More from xSawyer (14)

Recently uploaded (20)

Asynchronous programming FTW!