Typesafe stack - Scala, Akka and Play

3,413 views

Published on

Published in: Technology
  • Be the first to comment

Typesafe stack - Scala, Akka and Play

  1. 1. Typesafe stackScala, Akka and Play Luka Zakrajšek @bancek December 2012
  2. 2. The Typesafe Stack• development platform• easy to build scalable software applications• seamless integration with existing Java infrastructure
  3. 3. The Typesafe Stack• Java Virtual Machine• Scala core• Akka middleware• Play web framework• Tools• Horizontal scalability
  4. 4. Scala• general purpose programming language• object-oriented and functional• statically typed• full interoperability with Java• Twitter, Foursquare, Amazon, LinkedIn• active community
  5. 5. Object-Oriented• familiar design patterns from Java• traits• mixin-based composition
  6. 6. Functional• based on the functional principles of Haskell and ML• avoid shared state
  7. 7. Statically Typed• expressive type system• detects and avoids many kinds of application errors at compile time• no boilerplate code
  8. 8. Extensible• easy to add new language constructs• domain-specific languages (DSLs)
  9. 9. Interoperable with Java• Java bytecode• existing Java libraries• extremely mature Java Virtual Machine• no difference in deployment• familiar tools• shorter, faster, more correct code
  10. 10. Type inferenceval a = 5val b = 4.5val c = "foo"val error = a * cdef actOn[T](x: T) = x.toStringactOn(a)actOn(c)
  11. 11. Type aliases, closures,first class functions and comprehensionstype UnaryOp[T, R] = T => Rdef run[R](gen: UnaryOp[Int, R]) { for (x <- 1 to 5) println(gen(x))}run(x => -x)run(x => Array.fill(x)("*").mkString)
  12. 12. Imperative with functional-style constructsval someNumbers = List(1, 9, 2, 7, 3, 5)def onlyOdds = someNumbers.filter(_ % 2 == 1)def onlyEvens = someNumbers.filter(_ % 2 == 0)def sum = someNumbers.sumdef sumAlt = someNumbers.fold(0)(_ + _)
  13. 13. Traits: static mixinstrait Logging { protected def log(fmt: String, args: Any*) { println(fmt.format(args:_*)) }}class SampleClass extends Logging { log("Init") val a = 1 val b = "foo" log("%d and %s", a, b)}
  14. 14. Pattern matchingdef act: Either[Any, Exception] //...act match { case Left(message: String) => println(message) case Left(count: Int) => counter += count case Left(fallback: Any) => println("Error") case Right(e) => e.printStackTrace()}
  15. 15. Akka• event-driven middleware framework• high performance and reliable distributed applications• decouples business logic from low-level mechanisms• easily configurable
  16. 16. Simpler Concurrency• Threads and nonblocking IO are complex and error-prone• Actor concurrency model
  17. 17. Transactions• software transactional memory (STM)• atomically modify the state of many objects at once• revert all your changes if the transaction fails
  18. 18. Event-driven• platform for asynchronous event-driven architectures• non-blocking IO frameworks
  19. 19. Scalability• multicore servers and multiple nodes• several million Actors on single machine
  20. 20. Fault-tolerance• supervisor hierarchies• Let It Crash
  21. 21. Transparent Remoting• Remote Actors• distributed programming model• unified programming model
  22. 22. Scala & Java APIs• smooth interoperability• Spring and Guice integrations• deploy in your existing Java application server or run stand-alone
  23. 23. Actors• every actor has a message queue• actors accepts and choose what to do with messages• lightweight and asynchronous
  24. 24. Actors• actors tend to remain bound to single thread• actors rarely block, thread can remain active for a long duration• Akka actors occupy 650 bytes
  25. 25. class GreetingActor extends Actor { private var counter = 0 def receive = { case message => { counter += 1 // 1) Hello, Juliet log.info(counter + ") Hello, " + message) } }}val greetingActor = actorOf[GreetingActor].startgreetingActor ! "Juliet"
  26. 26. Play Framework• painless web development for Java and Scala• developer productivity• RESTful architectures• clean alternative to bloated Enterprise Java stacks
  27. 27. Live reload• fix the bug and hit reload• no need to restart the server
  28. 28. Stateless MVC architecture• shared-nothing architecture• use Ajax or offline storage to solve the state problems client-side• easier to render portions of the page in parallel
  29. 29. Type-safe templating engine• Scala-based template engine• syntax and type errors detected by compiler• routing system is also fully type-checked
  30. 30. Full-stack application framework• relational database support and object- relational mapping• integrated cache support• straightforward RESTful web services• flexible deployment options
  31. 31. Controllerpackage controllersimport play.api.mvc._object Application extends Controller { def index = Action { Ok("It works!") }}
  32. 32. Router# Extract the page parameter from the path, or fixthe value for /GET / controllers.Application.show(page = "home")GET /:page controllers.Application.show(page)
  33. 33. Scala IDE for Eclipse• syntax highlighting, code completion, inferred type hovers...• mixed Scala/Java projects• incremental compilation• 3rd party support for IntelliJ and NetBeans
  34. 34. Simple Build Tool (sbt)• compile code• run tests• package jars• manages dependencies
  35. 35. When not to use it• developers familiar with Python or Ruby• already have big codebase
  36. 36. Troubles• compiler is sometimes very slow• Scala developers are hard to find• Buggy tools• Play Framework 2 is still young
  37. 37. Why do we use it?• Python as first choice• a lot of long-lived connections• good support for WebSockets• when it compiles, it’s fast
  38. 38. Why do we use it?• most components in Scala and Play• also Python and Node.js• Thrift for communication between components• Akka for client connections and blocking operations
  39. 39. Why do we use it?• RESTful API on server• JavaScript (Angular.JS) on frontend• router generates helpers for JavaScript
  40. 40. Questions?

×