Scala Applied, Part 3

Part 3 of Scala Applied, covering Scala's core libraries

What you'll learn

Use case classes to get lots of free, best practice functionality

Contruct pattern matches like a Scala pro

Create and use PartialFunctions

Create, and manipulate Futures to avoid blocking and write reactive code

Obtain an in-depth grounding in the Scala collections and examine the enormous potential and power in the collections API

Know which collections to use in different circumstances to get desired performance

Use Option types instead of nulls to virtually eliminate NullPointerExceptions

Harness Java libraries effectively and safely, and even improve them in Scala

Know how to mix Java and Scala on a project, if you need to

Build your project using sbt

Write custom tasks and settings in sbt

Requirements

Students should follow and complete the Stairway to Scala Setup Instructions, available for free on Udemy, before starting this course

Students should have completed parts 1 and 2 of Stairway to Scala Applied, or have equivalent skills to having completed those two parts before starting this course

Students will need a laptop or desktop computer with sufficient performance and resources to compile and run the coding exercises

Description

Scala Applied, part 3 is the final part of this Scala programming language course. The course in its entirety is aimed at giving you a full, day-to-day working knowledge of Scala programming, including some of the most common core library APIs.This part starts with a final language feature for Scala (continuing from the other language features covered in parts 1 and 2). Pattern matching, partial functions and case classes are examined, how they can be used together, and how partial functions can help you avoid certain runtime errors by validating input to a function before you call it.Then we delve into the collections API in the core libraries (a very in-depth 2 module examination of the capabilities and performance tradeoffs of the various collection options), and finish up with a look at using Scala on Java projects, using Java libraries from Scala and how to harness build tools (particularly SBT) to build your project and even write custom settings and tasks. Following that we look at the Futures API in the core libraries.This course is also a good lead-in to the Stairway to Scala Advanced 3 part course which concentrates on in-depth language features, higher level functional abstractions, common patterns and idioms, type theory and other more advanced Scala concepts that will be particularly helpful for anyone writing their own libraries and APIs in Scala.

Overview

Section 1: Course Introduction and Exercises

Lecture 1 Download the exercises for this course

Lecture 2 Download Slides and Exercises

Section 2: Module 12 - Pattern Matching

Lecture 3 01 - Module 12 Introduction

Lecture 4 02 - Agenda

Lecture 5 03 - Simple Constant Patterns

Lecture 6 04 - match is an expression

Lecture 7 05 - Variable Loads

Lecture 8 06 - Binding vs Loading

Lecture 9 07 - Case Matters!

Lecture 10 08 - Case Matters Continued!

Lecture 11 09 - Guards

Lecture 12 10 - The Wrong Way to Guard

Lecture 13 11 - Matching Options

Lecture 14 12 - Matching Tuples

Lecture 15 13 - Matching Lists

Lecture 16 14 - Other Collections

Lecture 17 15 - Matching Try

Lecture 18 16 - Case Classes 1

Lecture 19 17 - Case Classes 2

Lecture 20 18 - Case Classes 3

Lecture 21 19 - Compound Pattern Matches

Lecture 22 20 - Typed Pattern Matches

Lecture 23 21 - Beware Type Erasure!

Lecture 24 22 - val and Pattern Matching

Lecture 25 23 - for and Pattern Matching

Lecture 26 24 - Partial Functions and Pattern Matches

Lecture 27 25 - Sealed Class Hierarchies

Lecture 28 26 - Extractors and unapply

Lecture 29 27 - Custom Extractors

Lecture 30 28 - Custom Seq Extractors

Lecture 31 29 - Module 12 Exercises

Section 3: Module 13 - Lists

Lecture 32 01 - Module 13 Introduction

Lecture 33 02 - Agenda

Lecture 34 03 - The Immutable Linked List

Lecture 35 04 - List Properties

Lecture 36 05 - Initializing Lists

Lecture 37 06 - Converting to Lists

Lecture 38 07 - List is Covariant

Lecture 39 08 - Constant Time Operations

Lecture 40 09 - Linear Time Operations

Lecture 41 10 - Operations that Depend on Position

Lecture 42 11 - Higher Order Functions

Lecture 43 12 - Predicate Based Functions

Lecture 44 13 - Folds

Lecture 45 14 - Fold Alternatives

Lecture 46 15 - Sorting

Lecture 47 16 - Even More Functions

Lecture 48 17 - And More

Lecture 49 18 - Permutations and Combinations

Lecture 50 19 - Indices, zip, unzip

Lecture 51 20 - Module 13 Exercises

Section 4: Module 14 - Collections

Lecture 52 01 - Module 14 Introduction

Lecture 53 02 - Agenda

Lecture 54 03 - Other Collections

Lecture 55 04 - Sequences Performance

Lecture 56 05 - Sets and Maps Performance

Lecture 57 06 - LinearSeq vs IndexedSeq

Lecture 58 07 - mutable vs immutable

Lecture 59 08 - Consistent API

Lecture 60 09 - Easy Conversions

Lecture 61 10 - Other Sequences

Lecture 62 11 - The Mighty Vector

Lecture 63 12 - Vector (continued)

Lecture 64 13 - Immutable Sets

Lecture 65 14 - Sorted and Mutable Sets

Lecture 66 15 - Maps

Lecture 67 16 - Sorted and Mutable Maps

Lecture 68 17 - Key and Value Operations

Lecture 69 18 - Immutable Implementations

Lecture 70 19 - Mutable Implementations

Lecture 71 20 - Iterators

Lecture 72 21 - Views

Lecture 73 22 - Streams

Lecture 74 23 - Module 14 Exercises

Section 5: Module 15 - Building Scala, SBT, Java Compatibility

Lecture 75 01 - Module 15 Introduction

Lecture 76 02 - Agenda

Lecture 77 03 - Maven

Lecture 78 04 - Gradle

Lecture 79 05 - Other Options

Lecture 80 06 - SBT

Lecture 81 07 - Using SBT

Lecture 82 08 - SBT Project Source Layout

Lecture 83 09 - build.sbt

Lecture 84 10 - Example build.sbt

Lecture 85 11 - Example plugins.sbt

Lecture 86 12 - Making a Custom Setting

Lecture 87 13 - A Custom Task

Lecture 88 14 - Multiple Project Support

Lecture 89 15 - Mixing Scala and Java

Lecture 90 16 - Scala/Java Compile Cycle

Lecture 91 17 - Calling Java from Scala

Lecture 92 18 - Scala 2.12 and Java 8

Lecture 93 19 - Scala/Java Function Compatibility

Lecture 94 20 - Handling Nulls

Lecture 95 21 - Options to Nulls

Lecture 96 22 - Java -> Scala Collections

Lecture 97 23 - Boxed Types Trouble

Lecture 98 24 - Scala Traits and Java Interfaces

Lecture 99 25 - General Advice

Lecture 100 26 - Module 15 Exercises

Section 6: Module 16 - Futures

Lecture 101 01 - Module 16 Introduction

Lecture 102 02 - Agenda

Lecture 103 03 - Futures

Lecture 104 04 - Creating a Future

Lecture 105 05 - Some Initial Rules

Lecture 106 06 - Future States

Lecture 107 07 - Composing Futures

Lecture 108 08 - Futures with for

Lecture 109 09 - Async Evaluation

Lecture 110 10 - Forcing a Result

Lecture 111 11 - Other Future Operations

Lecture 112 12 - More Operations

Lecture 113 13 - Recovering from Failures

Lecture 114 14 - Dealing with Multiple Futures

Lecture 115 15 - Other Future Sequence Operations

Lecture 116 16 - Promises

Lecture 117 17 - A Broken Promise

Lecture 118 18 - Working with Java's Futures

Lecture 119 19 - Future Patterns - Batching

Lecture 120 20 - foldLeft and flatMap

Lecture 121 21 - Future Patterns - Retrying

Lecture 122 22 - Retrying (naive)

Lecture 123 23 - Retrying (loop)

Lecture 124 24 - Retrying with Back-off

Lecture 125 25 - Retrying with Back-off 2

Lecture 126 26 - Future Alternatives

Anyone wanting to learn the Scala programming language,This is part 3 of a 3 part course, please check you have skills equivalent to parts 1 and 2 before taking this course,We do assume the student has some programming knowledge in a modern programming language other than Scala