Download as PDF, PPTX
 = x.toString
actOn(a)
actOn(c)](https://image.slidesharecdn.com/typesafe-121220074433-phpapp02/75/Typesafe-stack-Scala-Akka-and-Play-11-2048.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/75/Typesafe-stack-Scala-Akka-and-Play-12-2048.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/75/Typesafe-stack-Scala-Akka-and-Play-15-2048.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/75/Typesafe-stack-Scala-Akka-and-Play-26-2048.jpg)
Uploaded byLuka Zakrajšek
Typesafe stack - Scala, Akka and Play
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.
More Related Content
Similar to Typesafe stack - Scala, Akka and Play
![[Start] Playing](https://cdn.slidesharecdn.com/ss_thumbnails/start-playing-121117211541-phpapp02-thumbnail.jpg?width=640&height=640&fit=bounds)
Typesafe stack - Scala, Akka and Play
- 1. Typesafe stack Scala, Akkaand 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 purposeprogramming language • object-oriented and functional • statically typed • full interoperability with Java • Twitter, Foursquare, Amazon, LinkedIn • active community
- 6. Object-Oriented • familiar designpatterns from Java • traits • mixin-based composition
- 7. Functional • based onthe functional principles of Haskell and ML • avoid shared state
- 8. Statically Typed • expressivetype system • detects and avoids many kinds of application errors at compile time • no boilerplate code
- 9. Extensible • easy toadd 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, firstclass 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 traitLogging { 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 middlewareframework • high performance and reliable distributed applications • decouples business logic from low-level mechanisms • easily configurable
- 17. Simpler Concurrency • Threadsand nonblocking IO are complex and error-prone • Actor concurrency model
- 18. Transactions • software transactionalmemory (STM) • atomically modify the state of many objects at once • revert all your changes if the transaction fails
- 19. Event-driven • platform forasynchronous event-driven architectures • non-blocking IO frameworks
- 20. Scalability • multicore serversand multiple nodes • several million Actors on single machine
- 21. Fault-tolerance • supervisor hierarchies •Let It Crash
- 22. Transparent Remoting • RemoteActors • distributed programming model • unified programming model
- 23. Scala & JavaAPIs • smooth interoperability • Spring and Guice integrations • deploy in your existing Java application server or run stand-alone
- 24. Actors • every actorhas a message queue • actors accepts and choose what to do with messages • lightweight and asynchronous
- 25. Actors • actors tendto remain bound to single thread • actors rarely block, thread can remain active for a long duration • Akka actors occupy 650 bytes
- 26. class GreetingActor extendsActor { 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 • painlessweb development for Java and Scala • developer productivity • RESTful architectures • clean alternative to bloated Enterprise Java stacks
- 28. Live reload • fixthe 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._ objectApplication extends Controller { def index = Action { Ok("It works!") } }
- 33. Router # Extract thepage parameter from the path, or fix the value for / GET / controllers.Application.show(page = "home") GET /:page controllers.Application.show(page)
- 34. Scala IDE forEclipse • 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 touse it • developers familiar with Python or Ruby • already have big codebase
- 37. Troubles • compiler issometimes very slow • Scala developers are hard to find • Buggy tools • Play Framework 2 is still young
- 38. Why do weuse it? • Python as first choice • a lot of long-lived connections • good support for WebSockets • when it compiles, it’s fast
- 39. Why do weuse 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 weuse it? • RESTful API on server • JavaScript (Angular.JS) on frontend • router generates helpers for JavaScript
- 41.