Asynchronous programming FTW!

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)
mcgt$ieaul;
i  mcsces){
f($eh>ucs
  $eh>lc(NwMve';
  mccik'e ois)
  i  mcsces){
  f($eh>ucs
    m mve  mcfn_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
mcgt cnm_r,sb{
  $eh>lc('e ois,sb{
  mccik NwMve' u
    $eh>idipt(.. u  y@ois=@
    mcfn_nus .,sb{m mve  _})
  })
   ;
})
;

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

m jn  uo>e(
y$uo=Jnnw
  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   jnaayepn_eut
          $aa>'ter}
          dt{sdr',
        )
        ;

        $ef>e_ot hs,$v ;
        slsths($ot ag)
      }
      ,

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

        $ef>eeehs(hs)
        sldlt_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
  frahm eet(ky eet
  oec y$vn  es%vns){
    $vn(;
    eet>)
  }

}

wie(){
hl 1
  frahm eet(ky eet
  oec y$vn  es%vns){
    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:Lonw
y$op=I:Ayc:op>e;

$op>onc(
locnet
  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;
lorn

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

  $tem>ofgr(
  sracniue
    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';
  srawie'niiilln ee)

  $op>d(sra)
  load$tem;
}

ANOTHER EXAMPLE
$pr MO:sn Me:Ayc:TP
elI:AycNt:sn:HT E'
  I:Ayc>d(m ht  e:Ayc:TP>e ;
  O:snad y$tp=Nt:sn:HTnw)
  syfrI:Ayc>wi_l(mp{$tp>e(_  )
  a o O:snaatal a  htgt$)}
'>lsfUL.x
  itoRstt

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 #AtnldsPE:enladPE:eso.
s O;  uoicue O:Kre n O:Ssin

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

fr(.1){
o 1.0
  PE:esocet(
  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:Krern)

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

sbhnlriceet{
u ade_nrmn
sy"eso ,$esoI,"cutdt ,+$ep>'on';
a Ssin" ssin>D  one o" +ha{cut}
$enl>il(iceet)i ha{cut}<1;
kreyed'nrmn' f$ep>'on'  0
}

sbhnlrso
u ade_tp{
sy"eso ,$[ESO]>D  a tpe"
a Ssin" _SSINI,"hssopd;
}

sbhnlrsat{
u ade_tr
sy"eso ,$esoI,"hssatd;
a Ssin" ssin>D  a tre"
$ep>'on'  ;
ha{cut}=0
$enl>il(iceet)
kreyed'nrmn';
}
sbhnlriceet{
u ade_nrmn
sy"eso ,$esoI,"cutdt ,+$ep>'on';
a Ssin" ssin>D  one o" +ha{cut}
$enl>il(iceet)i ha{cut}<1;
kreyed'nrmn' f$ep>'on'  0
}
sbhnlrso
u ade_tp{
sy"eso ,$[ESO]>D  a tpe.n;
a Ssin" _SSINI,"hssopd"
}
fr(.1){
o 1.0
  PE:esocet(
  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:Krern)

MORE CONDENSED
uePE
s O;

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

  PE:esocet(
  O:Ssin>rae
    iln_tts=
    niesae >{
      _tr  = u
      sat  >sb{
        sy"eso ,$[ESO]>D  a tre"
        a Ssin" _SSINI,"hssatd;
        PE:enl>il(iceet)
        O:Kreyed'nrmn';
      }
      ,
      iceet= u
      nrmn >sb{
        PE:enl>il(iceet)i +cut<1;
        O:Kreyed'nrmn' f+$on  0
        sy"eso ,$[ESO]>D  one o$on"
        a Ssin" _SSINI,"cutdt cut;
      }
      ,
      _tp  = u
      so   >sb{
        sy"eso ,$[ESO]>D  a tpe"
        a Ssin" _SSINI,"hssopd;
      }
      ,
    }

  )
  ;
}

PE:enl>u(;
O:Krern)

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 pnw)>u_l(;
xtAp>e(rnal)

COMPLEX? TRY THIS...
ueRfe:Itra;
s elx:nevl

m t=Rfe:Itranw
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  =Ayvncnvr
y$v   nEet>oda;
m t  =Ayvntmr
y$    nEet>ie(
  atr  >2
  fe  = ,
  itra >06
  nevl= .,
  c    >sb{
  b   = u
    sy'h iei o:' nEet>o;
    a Tetm snw ,Ayvnnw
    +$on =1 n csn;
    +cut= 0ad$v>ed
  }
  ,
);

$v>ev
crc;

m w w=Ayvni(
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!

More Related Content

What's hot (12)

Similar to Asynchronous programming FTW! (20)

More from xSawyer (14)

Recently uploaded (20)

Asynchronous programming FTW!