Scala for C# and Java Developers.

Duration: 4 days

This is a great course that familiarises Java and C# developers with Scala.

This fresh course equips developers with all the tools necessary to function as a successful and productive team member on all Scala projects.

Please find the course objectives below:

Recently updated to Scala 2.12

Introduction

  • Introduction to the Scala language
  • Understand key features of the language
  • Explore lexical syntax
  • Understand basic declarations and definitions (var, val and def)
  • Understand basic types
  • Understand Scala's Rich Wrappers
  • Understand method declarations
  • Understand aspects such as multiple parameter clauses, default values, repeated parameters
  • Understand function application ("calling" functions)
  • List basic syntax: assignments and if-expression

Classes, Objects and Traits

  • Understand scala's hierarchy (Any and AnyVal)
  • Understand the bottom types Nothing and Null
  • Be able to define classes
  • Appreciate the access modifiers and further qualification
  • Understand the concept of properties in Scala
  • Method overloading
  • Define constructors (primary and auxiliary)
  • Understand class inheritance (nominal sub-typing)
  • Be able to apply the Liskov Substitution Principle
  • Concepts such as abstract members and overriding (methods and vals)
  • Define Objects in Scala
  • Understand the concepts of Companion Objects and their typical use
  • Discuss recommended invocation styles (e.g, infix)
  • Appreciate case classes
  • Define value classes
  • Organise classes/objects in packages
  • Discuss different styles of importing packages and classes/objects
  • Appreciate the package object
  • Introduce lazy values and early definitions
  • Understand Traits
  • Understand the Stackable Trait Pattern

Functions

  • Functions as objects and values
  • Use methods on functions (compose, ...)
  • Work with Higher order functions
  • Work with Recursion and tail recursive functions
  • Use Lambda expressions
  • Understand clojures
  • Use and understand the rules for parameters expansion (placeholder syntax)
  • Understand the difference between methods and functions
  • Using methods as functions (and eta-expansion)
  • Appreciate currying (methods and functions)
  • Use partially applied functions

Collections

  • Understand the type hierarchy (Traversable, Iterable etc)
  • Perform access/update/prepend/etc operations on Seq, Set and Map
  • Discuss performance implications of implementations
  • Access list using head/tail operations
  • Introduce lazy streams
  • Appreciate Ranges
  • Ordering using 'Ordered' and 'Ordering'
  • Using higher-order functions ('map' ,'reduce', 'fold' etc)
  • Introduce for-comprehensions

Types

  • Introduce type parametrisation type constructors
  • Define polymorphic methods
  • Understand the syntax of the type parameter clause
  • Use bounds (upper, lower and context)
  • Introduce variance (covariance, contravariance)
  • Discuss impact of (im)mutable types and variance
  • Appreciate Type declarations and definitions
  • Understand path dependent types

Implicits

  • Introduce implicit conversion and parameters
  • Use implicit conversions to convert expected types
  • Use implicit conversions to convert the received
  • Be able to pimp a library (using implicit classes)
  • Discuss the scoping rules of implicits
  • Define and use implicit parameters
  • Discuss use cases for implicit parameters
  • Introduce type classes
  • Explore how Scala and other libraries use implicits

Pattern Matching

  • Introduce the power of pattern matching
  • Understand all the various patterns
  • Understand the role of case classes
  • Build extractors
  • Understand sealed traits
  • Introduce Algebraic Data Types
  • Discuss various ways to build enumerated values in Scala
  • Understand pattern matching in value definitions, for comprehensions and function literals
  • Introduce the concept of Partial Functions

Monadic Data Types

  • Introduction to Monads
  • Use the Option monad
  • Appreciate monad composition (through flatMap)
  • Understand the role of for-comprehensions
  • Deal with exceptions in Scala (catching)
  • Use and understand Try
  • Use and understand Either
  • Introduce Futures and Promises

This course is unique in:

  • being not just example driven, but bringing a deeper understanding of the Scala language
  • explaining concepts that are often challenging in a clear manner (illustrating many approaches to different issues with the help of useful diagrams)
  • focusing on preparation for real-world projects (Testing, Integration with Java and some of its popular frameworks)
  • providing real-life examples and demonstrations for a heightened appreciation of how to apply classroom concepts to the real world situations

This course has recently been updated to incorporate Scala 2.12 reinforcing its status as a cutting-edge course that appeals to the developers working with the latest technologies.

For an onsite course please contact us