Jonas Boner's two day Pragmatic Real-World Scala course will teach you all you need to know about Scala, one of the most interesting new languages for the JVM. A unique and elegant blend of the Object-Oriented (OO) and Functional Programming (FP) paradigms, Scala is pragmatic and practical with seamless interoperability with Java.

Scala stands for 'Scalable Language' and is designed to scale with the needs and requirements of its users. It is statically typed but with good type inference and style which gives it a dynamic feel similar to Ruby or Python, but with the performance and safety only a statically typed language can provide. This makes it great for a wide range of use-cases, from internal DSLs to large-scale enterprise applications or container code.

LEARN HOW TO:

In this course we will give you an introduction to Scala from a Java/JEE and realworld perspective. Jonas also covers design and architecture throughout the course.You will learn how to:Make effective use of Scala's richer OO abstractions and type system, such as mixin composition, to create more flexible and reusable components and systemsTake advantage of Scala's FP nature, such as closures, high-order functions, immutability, for more clean, safe, conceptually coherent and deterministic codeMake concurrent programming and event-driven systems a walk in the park using Actors Use Actors to higly fault-tolerant applications that embraces failure and self-heals Bring it all together and make Scala work in the real world; with problems like Web development, O/R Mapping, Dependency Injection (DI), AOP,

PROGRAMME

This is a very practical workshop that will mix theory and practice, presentation and hands-on labs.

• High-level tour of Scala.
• Side-by-side comparison with Java.
• Basic syntax
• REPL
• Scripting in Scala

Composition in large:Object-Oriented Programming

• Mixin composition
• Modules
• Self-type annotations
• Duck typing (structural typing)
• Dependency Injection techniques in Scala

Composition in small: Functional Programming

• Functions
• High order functions
• Closures
• Call-by-name
• Currying
• Recursion, tail-call optimizations

Scala Collections

• Mutable collections
• Immutable collections
• Persistent datastructures
• Sequences
• Streams

For Comprehensions

• Syntax
• for-yield
• Compiler generated code

Pattern Matching

• Matching on literals and data types
• Case classes
• Matching on datastructures
• Partial functions
• Extractors
• Option & Either types
• Regexp
• mplicits
• Implicit conversions
• Implicit arguments
• Manifest file

Writing Domain Specific Languages (DSLs) in Scala

• Operator overloading
• Using call-by-name blocks
• Implicit conversions
• Parser combinators

Type System

• Parameterized classes

• Upper and lower type bounds
• Polymorphic methods

• Inner classes
• Abstract types
• Structural typing
• Explicitly typed self references

Concurrency

• The problem with locks
• Immutability
• The Actor model
• Event-driven actors
• Thread-based actors
• When to use which paradigm

Akka Transactors

• Active Objects vs Actors
• Supervisor hierarchies
• Remote Actors
• Transactors/STM
• Actor Persistence
• RESTful Actors
• Security
• Comet Actors
• Camel integration
• Spring & Guice integration

Java Interop

• Calling Java from Scala
• Calling Scala from Java
• Exceptions

Tools & Frameworks

• Scala distribution tools
• IDE overview
• Build tools
• Middleware frameworks

Scala in the Enterprise

• Testing Scala
• Logging
• JPA
• JDBC (ScalaQuery)
• JTA
• REST
• HTTP
• Web development: Lift Web Framework and more
• Messaging
• XML/XPath
• AOP
• Real-World Deployment

Domain modeling

• Working with an immutable domain model
• Entities
• Value objects

New in Scala 2.8

• Named arguments + default arguments
• @specialized
• Package objects
• Immutable copy of case classes