Promise  of  a  be,er   future   Pooja  Akshantal   Rahul  Goma  Phulore   

Who  are  we?   

What  we  are  going  to  talk  about   •  How  concurrency  and  parallelism  are  different   ideas   •  Why  concurrency  is  important   •  Futures  and  promises     •  DEMO!   •  PiGalls   

Concurrency  ≠  Parallelism   Concurrency  is  a  program-­‐ structuring  technique  in  which   there  are  mulJple  threads  of   control   A  parallel  program  is  one  that   uses  a  mul5plicity  of   computa5onal  hardware  (e.g.   mulJple  processor  cores)   Structure   Execu5on   Dealing  with  lots  of  things  at   once   Doing  lots  of  things  at  once     

Orthogonality  illustrated   Javascript   promises,  Python   generators   Java  and  Scala   futures   Well…  lots  of   things   Parallel  collecJons   

Fall  of  Moore’s  law   

Age  of  mulJcore   •  MulJcore  has  become  a  norm!   •  Need  to  exploit  parallelism  to  perform   •  Good  concurrency  abstracJons  a  way  to   get  there   

Futures  and  promises   

Futures  and  promises   •  Can  be  thought  of  as  a  single  concurrency   abstracJon   

Future  ≈  Cheap  thread   •  Futures  are  mulJplexed  dynamically  onto   threads  as  needed.     •  Managed  by  Execu5onContext.   •  It’s  pracJcal  to  have  hundreds  of  thousands   going  at  once.   •  Spawn  away!     

Code  Time   

Async  and  non-­‐blocking   •  Goal:  Do  not  block  current  thread  while   waiJng  for  the  result  of  the  future.   •  Callbacks:   – Register  callback  which  is  invoked  asynchronously   when  future  is  completed   – Async  computa5ons  do  not  block   

Callbacks?!   

There  is  a  soluJon!   •  Higher-­‐order  funcJons  /  combinators   •  for-­‐comprehensions   •  Other  abstracJons   

Running  example   •  Collect  staJsJcs  for  a     facebook  page   •  For  every  post  on  the     page:   – Collect  all  likes   – Collect  all  comments   •  Aggregate  results  into  popularity  score   

Code  Time   

Other  parallels   •  Error  recovery  combinators   –  recover   –  recoverWith   •  CollecJon  operaJons   –  map: (Seq[A], A ⇒ B) ⇒ Seq[B]
 
 mapF: (Seq[A], A ⇒ Future[B]) ⇒ Future[Seq[B]]
 –  filter: (Seq[A], A ⇒ Boolean) ⇒ Seq[A]
 
 filterF: (Seq[A], A ⇒ Future[Boolean]) ⇒ Future[Seq[A]] 

PiGalls   •  InteracJons  with  thread-­‐unsafe  libraries   •  ThreadLocal  variables   •  Retries,  Jme-­‐outs  not  very  natural   •  Simpler  than  other  concurrency  models  in   many  ways,  but  sJll  incur  some  cogniJve  cost   

Credits   •  Heather  Miller,  for  her  material  on   relaJonship  between  futures  and  promises   •  Simon  Marlow  and  Rob  Pike,  for  their   material  on  concurrency  and  parallelism   •  Josh  Suereth,  for  his  Github  example   (InspiraJon  for  our  facebook  example)   •  Scala,  Play,  and  Akka  teams  for  all  their   amazing  work   

Thank  You!   ☺