• Noah's father, Sandrine's husband
• Studied some Maths and Informatics at ULg
  
• Did some work in the Geospatial fields (provisionning)
• Also a bit in medical and web
• Co-founded @NextLab_be (still borning)
• Co-founded @wajug (come in!)
• OKFN member & Hackathon eGov Wallonia believer
• Devoxx 4 Kids trainer
• Scala enthusiast and trainer in '14
• Author of Learning Play! Framework 2 (Packt Publishing)
• Big Data technologies lover

PLAY!2 IS A WEB FRAMEWORK

• Scala ^-^
  
• Non-Blocking and Async (Netty, Akka, ...)
  
• HTTP is the basis, REST is the philosophy (brings WebSocket, SSE, Comet out-of-the-box)
  
• Json as first class citizen (code generation at compile time brings type safety in SeDese)
• Open Source but supported by TypeSafe Inc.
  
• JVM compliant: the Java's ecosystem is wide
  
• Scala's ecosystem is evolving really fast
  
• Activator reduces the needs to the browser only

 trait DB

 class Connection

 case class User

 object JDBC

 implicit val session:DBSession case class User(first:String) {   def update(force:Boolean=false)(implicit s:DBSession) = ... }

 object JsonFeed {
   def add(j:Json):JsonFeed = ... } object Main {   implicit def userToJson(u:User):Json = ...
   implicit def newsToJson(n:News):Json = ...   JsonFeed.add(User("me")).add(News("Belighted hosts Scala")) }

 implicit class UserJson(u:User) {   def out:Out[Json] = ... } implicit class UserMessagePack(u:User) {   def out:Out[MessagePack] = ... } object JsonWorld {
   import UserJson
   val out  = User("me").out }

 object MessagePackWorld {   import UserMessagePack
   val out = User("me").out }

 trait JsonSer[U] {   def convert(u:U):Json } case class User(first:String) case class News(message:String) object Implicits {   implicit object UserJsonSer extends JsonSer[User] { //impl }   implicit object NewsJsonSer extends JsonSer[News] { //impl } } object JsonFeed {   def add[M : JsonSer](m:M) = implicitly[JsonSer[M]].convert(m) } object Main {   import Implicits._   JsonFeed.add(User("...")).add(News("...")) } 

 trait Monoid[M] {   def `0`:M   def +(m1:M, m2:M) } object Implicits {   implicit object IntMonoid extends Monoid[Int] {     val `0` = 0     def +(i1,i2) = i1 + i2   }   implicit object ListMonoid[Int] extends Monoid[List[Int]] {
     val `0` = 0
     def +(l1,l2) = l1 ::: l2
   } } object Main {   def sum[M:Monoid](list:List[M]):M = {     val m = implicitly[Monoid[M]]     list.foldLeft(m.`0`) { (curSum, i) =>       m.+(curSum, i)     }   }

 sealed trait Option[A] case class Some[A](a:A) extends Option[A] case object None extends Option[Nothing]

 trait Future[A] {   def map[B](f:A=>B)   def flatMap[B](f:A=>Future[B]) }