Tuesday, May 31, 2011 at 9:00 AM - Wednesday, June 1, 2011 at 5:30 PM (PDT)
Training Course Participants And Objective
A two day course intended for developers with at least 3 months of production programming experience with Scala who need to understand its advanced features, as well as good library or DSL design practices.
It will take place in the Tresidder Memorial Union on the Stanford University campus a short walking distance from the Scala Days 2011 conference facility on the 31 May and 1 June 2011.
This course combines presentations with live coding examples and will be given by Martin Odersky.
Objective: This course provides knowledge and skills necessary for writing high-quality Scala libraries and frameworks. It concentrates primarily on library providers' needs, going beyond the point of view of library consumers.
Prerequisites: We assume you have a solid knowledge of Scala application programming (typically, 3 months or more of production experience with the language should be sufficient).
Format: The course is hands-on, combining lectures with exercises and mini-projects. This being an advanced class there will room left for free discussions and explorations of topics you want to bring up.
Part 1: Type Types
A review of Scala's toolbox for defining types and type abstractions. You'll discover all aspects of generics and get some guidance when to use type members or existential types instead. There's also coverage of how to use structural types to reduce coupling.
- Type parameters
- Upper and lower bounds
- Abstract types and type aliases
- Existential types vs abstract type members
- Structural types
Part 2: Explicitly Implicit
Implcits are the scalpel of a competent Scala programmer's tool box: Versatile and powerful, but to be used with forethought and precision. This unit will take you through the main kinds of implicit definitions in Scala and will present powerful design patterns that are based on implicits.
- Implicit conversions
- Implicit parameters
- Type classes
- Generalized type constraints via implicits
Part 3: Adding to Collections
Collections are the primary example of an intricate framework that was designed for re-usable components. This unit will present the architecture of the collections framework, focusing on its use of generics, implicits, and higher-kinded types. It will contain case studies that show how you can extend the framework with your own collections, so that in a few lines you can inherit the functionality of all bulk operations at the right types. It will introduce Scala's new parallel collections and show how you can write your own.
- Collection library design
- Base classes and template classes
- Using implicits
- Using higher-kinded types
- Writing your own collection classes
- Making it parallel
Part 4: From Libraries to Languages
Scala lends itself to very high-level APIs that can become domain specific languages. This unit reviews of the fundamental techniques that Scala offers for writing such embedded DSLs. It also shows you examples of some concrete DSLs that make use of the techniques.
- Customizing syntax
- Customizing pattern matching: extractors
- Regular expressions
- Case study: contracts
- Case study: parser combinators
- Going all the way: language virtualization
Part 5: Putting everything together
This unit combines what you have learned so far in a concrete application, which combines GUI programming, reactive prigramming, expression evaluation in a modular and extensible system.
- GUI programming
- Abstract expression trees
Note Typesafe's training cancellation policy is:
* Full refund with 10 working days notice by email to firstname.lastname@example.org.
* 80% refund with 5 days notice.
* 25% refund with less than 5 days notice.