Learn By Example: Scala

Name: Learn By Example: Scala
Rating: 4.0 (690 reviews)

65 examples that will bring Scala to life for you

Created byLoony Corn

Last updated 2/2018

English

English [Auto],

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

Course content

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

You, This Course and Us2:21

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
Explore match expressions in Scala, including pattern guards and or-ed expressions, to extend conditions with boolean expressions and value bindings.
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
Explore two for loop styles in Scala: value binding over a list and numeric ranges using until or to; and learn how foreach, map, and flatMap offer alternatives.
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
Discover how Scala treats functions as objects and entities, defined with the value keyword and stored in val or var, while methods use def and stay tied to a class.
Example 22 - Functions are named, reusable expressions6:06
Learn that functions are named, reusable expression blocks with parameters and return values, behaving like first-class functions and enabling closures across scope in Scala.
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
Learn how procedures are named, reusable statements in Scala that are functions without a return value, must produce a side effect to change state, and use def with Unit.
Example 30 - Functions with No Inputs3:40
Explore Scala methods with and without parentheses, where parentheses denote function-like behavior and methods without parentheses look like properties, and learn how the compiler enforces their invocation.
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
Explore by-name parameters in Scala, showing how the first evaluation is lazy and every subsequent reference triggers ego evaluation for both functions and methods.
By-Name Parameters
Example 38 - Closures10:11
Explore closures in Scala, where nested functions capture their referencing environment and outlive their outer scope. Learn how higher-order functions return language-specific greetings.

Module Outline - Collections0:28
Discover how Scala supports collections with higher-order functions, where container classes provide methods that apply function objects to their elements in powerful ways.
Example 39 - Tuples10:31
Learn Scala tuples as ordered, immutable containers of heterogeneous values. Create with parentheses, access with _1, _2, or deconstruct into variables; they are not true collections, making iteration awkward.
Tuples
Example 40 - Creating Lists8:53
Explore creating and manipulating lists in Scala, including immutable lists, Nil, the cons operator ::, the apply method, and concatenation with ::: and ++, plus zip and flatten.
Example 41 - Simple List Operations7:48
Lists
Example 42 - Higher Order Functions Introduced12:49
Simple Higher Order Methods
Example 43 - Scan, ScanFold,ScanReduce11:51
Example 44 - Fold, FoldLeft, FoldRight2:28
Explore fold, foldLeft, foldRight and scan, scanLeft, scanRight in Scala. Understand how they relate and that they operate from right to left, with results shaped by leftmost and rightmost elements.
Example 45 - Reduce,ReduceLeft,ReduceRight5:21
Explore reduce, reduceLeft, and reduceRight in Scala, focusing on initial values and left versus right associative behavior, and compare them with scan.
Example 46 - Other, Simpler Reduce Operations2:39
Scan
Fold
Reduce
Example 47 - Sets and Maps11:23
Maps
Example 48 - Mutable Collections, and Arrays10:03
Mutable Collections and Arrays
Example 49 - Option Collections5:55
Example 50 - Error handling with util.Try4:07
Explore error handling in Scala using Try, comparing success and failure patterns with option collections to gracefully manage exceptions and specify a plan B.
Options

Module Outline - Classes0:34
Example 51 - Classes10:03
Example 52 - Primary v Auxiliary Constructors3:59
Primary Constructors
Example 53 - Inheritance from Classes6:03
Example 54 - Abstract Classes2:49
Example 55 - Anonymous Classes2:59
Explore anonymous classes in Scala to quickly instantiate abstract classes by redefining methods in braces and using new, with shape and sheep examples returning the value 100 for get area.
Example 56 - Type Parameters3:14
Example 57 - Lazy Values4:27
Example 58 - Default Methods with apply4:17
Example 59 - Operators4:30
Example 60 - Access Modifiers5:25
Example 61 - Singleton Objects5:33
Learn how singleton objects in Scala, defined with the object keyword, provide static-like behavior via companion objects, explain why Scala omits static, and define the entry point.
Example 62 - Companion Objects9:10
Explore companion objects in Scala, where a singleton object and a class share a name in the same file to access private data and implement a factory pattern via apply.
Example 63 - Traits6:10
Traits
Example 64 - Case Classes3:25
Example 65 - Self Types7:19

Requirements

Basic knowledge of programming, ideally in Java or C#
The course will cover the installation of Scala - no worries on that front!

Description

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.

Who this course is for:

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

Learn By Example: Scala

What you'll learn

Explore related topics

Course content

You, This Course and Us1 lecture • 2min

Introducing Scala9 lectures • 56min

Expressions or Statements?13 lectures • 1hr

First Class Functions20 lectures • 1hr 59min

Collections13 lectures • 1hr 34min

Classes and Objects16 lectures • 1hr 20min

Requirements

Description

Who this course is for: