Syllabus

These are the topics covered throughout the 10 days of the Scala course. They go from the basics, mostly in the first days, to advanced topics in the last days, such as implicits, structural typing, variance, extractors, etc:


Basics:
  • Hello World
  • Primitive Types
  • Type inference
  • Vars vs Vals
  • Lazy Vals
  • Methods
  • Pass By Name
  • Infix Notation
  • No parens/Brackets
  • Default Arguments
  • Named Arguments
Classes:
  • Introduction
  • Inheritance
  • Main/Additional Constructors
  • Private Constructors
  • Uniform Access
  • Case Classes
  • Objects
  • Traits
Collections:
  • Lists
  • Collection Manipulation
  • Simple Methods
  • Methods With Functions
  • Use Cases With Common Methods
  • Tuples
Options:
  • Option Implementation
  • Like Lists
  • Practice Application
Types:
  • Type parameterization
  • Covariance
  • Contravariance
  • Type Upper Bounds
  • 'Nothing' Type
Anonymous Classes:
  • Introduction
  • Structural Typing
  • Anonymous Classes With Structural Typing
Special Methods:
  • Apply
  • Update
Currying:
  • Introduction
  • Applications
Implicits:
  • Implicit Values/Parameters
  • Implicit Conversions
  • With Anonymous Classes
  • Implicit Classes
  • The 'Pipe' Operator
For Loops:
  • Introduction
  • Coding Style
  • With Options
  • And flatMap
  • Guards
  • Definitions
Var Args:
  • Introduction
  • Ascribing the _* type
Partial Functions:
  • Introduction
  • Match
  • Match Values/Constants
  • Match Types
  • Extractors
  • If Conditions
  • Or
  • With Collections
  • The Unapply
Recursion:
  • Examples
  • Optimization
More on Traits:
  • Stackable Traits
  • Examples
Advanced Types:
  • F-Bounded Polymorphism
  • Self Type Annotation
  • Introduction to Type Classes
Contents are only indicative and can change before and during the course.

The Scala creator, Martin Odersky, created a list of "skill levels" of developers with the Scala language.
Here's an overview of how the course relates to these levels proposed by the language creator:


Level A1: Beginning application programmer
Covered: Java-like statements and expressions: standard operators, method calls, conditionals, loops, try/catch
Covered: class, object, def, val, var, import, package
Covered: Infix notation for method calls
Covered: Simple closures
Covered: Collections with map, filter, etc
Covered: for-expressions

Level A2: Intermediate application programmer
Covered: Pattern matching
Covered: Trait composition
Covered: Recursion, in particular tail recursion
Covered: XML literals

Level A3: Expert application programmer
Covered: Folds, i.e. methods such as foldLeft, foldRight
Covered: Streams and other lazy data structures
Actors (*out of scope)
Combinator parsers (*a very specific topic, is now a community-maintained project, not part of the standard Scala library anymore)
Level L1: Junior library designer
Covered: Type parameters
Covered: Traits
Covered: Lazy vals
Covered: Control abstraction, currying
Covered: By-name parameters

Level L2: Senior library designer
Covered: Variance annotations
Existential types (*out of scope)
Covered: Self type annotations
The cake pattern for dependency injection (*there have been complains about the long-run maintainability of this pattern, and other issues)
Covered: Structural types (aka static duck typing)
Defining map/flatmap/withFilter for new kinds of for-expressions (*very specific feature, not needed in most projects)
Covered: Extractors

Level L3: Expert library designer
Early initializers (*very specific feature)
Abstract types (*out of scope)
Covered: Implicit definitions
Higher-kinded types (*out of scope)
Contact Us
Say Hey