Learn By Example: Scala

65 examples that will bring Scala to life for you

Last updated 2/2018

English

What you'll learn

Use Scala with an intermediate level of proficiency
Read and understand Scala programs - including those with highly functional forms - written by others
Identify the similarities and differences between Java and Scala, and use both to their advantage

6 sections • 72 lectures • 6h 51m total length

Introducing Scala: Java's Cool Cousin10:11
A quick run-through of the reasons why people are so excited about Scala
Installing Scala9:43
Let's plunge in! Setting up Scala is surprisingly simple. You do need Java though.
Examples 1 and 2 - Hello world5:05
Example 3 - Mutable and Immutable ‘variables’5:16
Immutable variables are a big part of Scala - understand why.
Example 4 - Type Inference6:34
Scala aims to achieve the best of both worlds: rapid prototyping like Python, type safety like Java, C++ and other statically typed languages.
Type Inference
Example 5 - String Operations4:29
Example 6 - A Unified Type System5:28
Scala has 3 types that unify the type system: Any (literally anything!), AnyRef (supertype to all reference types) and AnyVal (supertype to all value types)
Example 7 - Emptiness in Scala5:39
Nil, null, Null, Nothing, Unit..Scala has many ways to skin a non-existent cat!
Example 8 - Type Operations3:53

Module Outline - Loops and Conditionals0:30
Example 9 - Statements v Expressions5:57
This is an important semantic difference - statements don't return a value, while expressions do. Scala converts many familiar constructs into expressions - which allows them to be composed.
Example 10 - Defining Values and Variables via Expressions2:29
Expression blocks are prototypical "r-values", i.e. they sit on the right of assignment statements.
Example 11 - Nested Scopes in Expression Blocks4:53
Example 12 - If/Else expression blocks5:21
Scala has if-else expressions (not if-else statements). This is a fine point, and an important one.
Example 13 - match expressions5:39
Pattern matching is very easy in Scala - this is a more popular language construct than if/else expressions
Example 14 - match expressions: Pattern guards & OR-ed expressions4:26
Example 15 - match expressions: catch-all to match-all6:14
Example 16 - match expressions: down casting with Pattern Variables7:00
Pattern Matching
Example 17 - for loops can be expressions OR statements7:48
Scala has a way to convert for loop statements into for loop expressions - using 'yield'
Example 18 - for loops: 2 types of iterators3:17
Example 19 - for loops with if conditions: Pattern Guards2:39
Example 21 - while/do-while Loops: Pure Statements3:33
While loops are pure statements, and are rather clunky. See why they are not the most popular construct in town.
For Loops

Module Outline - Functions0:27
First Class Functions7:29
Functions are 'first class citizens' in Scala - this actually has a technical term!
Functions v Methods6:05
Example 22 - Functions are named, reusable expressions6:06
Example 23 - Assigning Methods to Values8:59
Example 24 - Invoking Functions with Tuples as Parameters5:57
Example 25 - Named Function Parameters3:38
Scala allows parameters to be specified out of order - using their names
Example 26 - Parameter Default Values3:59
Yet another mechanism to encourage code re-use
Parameter Default Values
Example 27 - Type Parameters: Parametric Polymorphism7:13
Scala loves using formidable terms for everyday concepts:-) Think generics in Java.
Example 28 - Vararg Parameters4:57
Example 29 - Procedures are named, reusable statements5:30
Example 30 - Functions with No Inputs3:40
Example 31 - Nested Functions4:04
Example 32 - Higher Order Functions7:37
Functions that take in other functions as parameters, or return function objects, are called Higher Order Functions
Higher Order Functions
Example 33 - Anonymous Functions (aka Function Literals)2:44
Example 34 - Placeholder Syntax7:00
Example 35 - Partially Applied Functions7:22
Partially Applied Functions are a really cool code re-use trick: fix some (but not all) parameters of a function and you have a new function!
Partially Applied Functions
Example 36 - Currying7:02
Parameter Groups
Example 37 - By-Name Parameters9:01
By-Name Parameters
Example 38 - Closures10:11

These 65 examples will make this cool-new-kid-on-the-block your steady, reliable friend

Let's parse that.

Scala is cool because its all the rage for big data applications, and because it manages to be more sophisticated and elegant than Java.

That said, Java is a steady, reliable friend - a language you can depend upon, and in which you can express yourself.

These 65 examples will help you trust Scala the way you trust Java. Each is self-contained, has its source code attached, and gets across a specific Scala use-case. Each example is simple, but not simplistic.

What's Included:

The Big Ideas: Before we get to the how, we better understand the why - this course will help clarify why we even need Scala when Java serves us so well

The Little Details That Matter: Pattern Matching, If Expressions, For Loops & Yield: Java has if-statements, while Scala has if-expressions. Differences like these matter, this course will cover them.

First Class Functions are perhaps the most dramatically new feature of Scala - the foundation of functional programming support.

Collections - Lists, Options, the Details of fold/reduce/shift in Scala are yet another bit of the language that differs significantly from other traditional object-oriented languages. We will spend a lot of time on these topics too.

Classes, Companion Objects, Traits, Self Types and Dependency Injection are Scala's way of providing Object Oriented support. Some of these concepts are similar to Java - those we will skim over. Others are quite different - we will be sure to cover these in detail.

Nope! Please don't enroll for this course if you are entirely new to programming
Yep! Please DO enroll for this course if you know Java and are now looking to learn Scala from first principles
Yep! Please DO enroll for this course if you are interested in learning functional programming concepts as embodied in Scala