Typesafe stack - Scala, Akka and Play
4 likes3,339 views
The Typesafe Stack includes Scala, Akka, and Play frameworks for building scalable applications. Scala is a statically typed, functional programming language that runs on the JVM and interoperates with Java. Akka is an event-driven middleware for building distributed, fault-tolerant applications using actors. Play is a web framework that enables fast development of RESTful APIs and web applications using Scala templates. Together, these frameworks provide tools for building scalable, distributed systems with easy development.
 = x.toString
actOn(a)
actOn(c)](https://image.slidesharecdn.com/typesafe-121220074433-phpapp02/85/Typesafe-stack-Scala-Akka-and-Play-11-320.jpg)
![Type aliases, closures,
first class functions and
comprehensions
type UnaryOp[T, R] = T => R
def run[R](gen: UnaryOp[Int, R]) {
for (x <- 1 to 5) println(gen(x))
}
run(x => -x)
run(x => Array.fill(x)("*").mkString)](https://image.slidesharecdn.com/typesafe-121220074433-phpapp02/85/Typesafe-stack-Scala-Akka-and-Play-12-320.jpg)
![Pattern matching
def 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()
}](https://image.slidesharecdn.com/typesafe-121220074433-phpapp02/85/Typesafe-stack-Scala-Akka-and-Play-15-320.jpg)
![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].start
greetingActor ! "Juliet"](https://image.slidesharecdn.com/typesafe-121220074433-phpapp02/85/Typesafe-stack-Scala-Akka-and-Play-26-320.jpg)
Typesafe stack - Scala, Akka and Play
- 1. Typesafe stack Scala, Akka and Play Luka Zakrajšek @bancek December 2012
- 2. The Typesafe Stack • development platform • easy to build scalable software applications • seamless integration with existing Java infrastructure
- 4. The Typesafe Stack • Java Virtual Machine • Scala core • Akka middleware • Play web framework • Tools • Horizontal scalability
- 5. Scala • general purpose programming language • object-oriented and functional • statically typed • full interoperability with Java • Twitter, Foursquare, Amazon, LinkedIn • active community
- 6. Object-Oriented • familiar design patterns from Java • traits • mixin-based composition
- 7. Functional • based on the functional principles of Haskell and ML • avoid shared state
- 8. Statically Typed • expressive type system • detects and avoids many kinds of application errors at compile time • no boilerplate code
- 9. Extensible • easy to add new language constructs • domain-specific languages (DSLs)
- 10. Interoperable with Java • Java bytecode • existing Java libraries • extremely mature Java Virtual Machine • no difference in deployment • familiar tools • shorter, faster, more correct code
- 11. Type inference val a = 5 val b = 4.5 val c = "foo" val error = a * c def actOn[T](x: T) = x.toString actOn(a) actOn(c)
- 12. Type aliases, closures, first class functions and comprehensions type UnaryOp[T, R] = T => R def run[R](gen: UnaryOp[Int, R]) { for (x <- 1 to 5) println(gen(x)) } run(x => -x) run(x => Array.fill(x)("*").mkString)
- 13. Imperative with functional-style constructs val someNumbers = List(1, 9, 2, 7, 3, 5) def onlyOdds = someNumbers.filter(_ % 2 == 1) def onlyEvens = someNumbers.filter(_ % 2 == 0) def sum = someNumbers.sum def sumAlt = someNumbers.fold(0)(_ + _)
- 14. Traits: static mixins trait 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) }
- 15. Pattern matching def 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() }
- 16. Akka • event-driven middleware framework • high performance and reliable distributed applications • decouples business logic from low-level mechanisms • easily configurable
- 17. Simpler Concurrency • Threads and nonblocking IO are complex and error-prone • Actor concurrency model
- 18. Transactions • software transactional memory (STM) • atomically modify the state of many objects at once • revert all your changes if the transaction fails
- 19. Event-driven • platform for asynchronous event-driven architectures • non-blocking IO frameworks
- 20. Scalability • multicore servers and multiple nodes • several million Actors on single machine
- 21. Fault-tolerance • supervisor hierarchies • Let It Crash
- 22. Transparent Remoting • Remote Actors • distributed programming model • unified programming model
- 23. Scala & Java APIs • smooth interoperability • Spring and Guice integrations • deploy in your existing Java application server or run stand-alone
- 24. Actors • every actor has a message queue • actors accepts and choose what to do with messages • lightweight and asynchronous
- 25. 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
- 26. 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].start greetingActor ! "Juliet"
- 27. Play Framework • painless web development for Java and Scala • developer productivity • RESTful architectures • clean alternative to bloated Enterprise Java stacks
- 28. Live reload • fix the bug and hit reload • no need to restart the server
- 29. 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
- 30. Type-safe templating engine • Scala-based template engine • syntax and type errors detected by compiler • routing system is also fully type-checked
- 31. Full-stack application framework • relational database support and object- relational mapping • integrated cache support • straightforward RESTful web services • flexible deployment options
- 32. Controller package controllers import play.api.mvc._ object Application extends Controller { def index = Action { Ok("It works!") } }
- 33. Router # Extract the page parameter from the path, or fix the value for / GET / controllers.Application.show(page = "home") GET /:page controllers.Application.show(page)
- 34. Scala IDE for Eclipse • syntax highlighting, code completion, inferred type hovers... • mixed Scala/Java projects • incremental compilation • 3rd party support for IntelliJ and NetBeans
- 35. Simple Build Tool (sbt) • compile code • run tests • package jars • manages dependencies
- 36. When not to use it • developers familiar with Python or Ruby • already have big codebase
- 37. Troubles • compiler is sometimes very slow • Scala developers are hard to find • Buggy tools • Play Framework 2 is still young
- 38. 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
- 39. 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
- 40. Why do we use it? • RESTful API on server • JavaScript (Angular.JS) on frontend • router generates helpers for JavaScript
- 41. Questions?