Scala 3: Just What You Need

Scala 3, Zero to Hero, Just the skills you need from just the language you want. Language, libraries, patterns.

What you'll learn

Scala Language Programming

Scala 3 New Syntax and Features

Scala Core Libraries, Including Collections and Futures

Scala Types, Traits, Pattern Matching, Functions

Practical Functional Programming in Scala

Requirements

Programming skills in at least one other programming language is recommended

Description

A complete introduction to the Scala 3 language teaching you all you need to know in order to use it on a daily basis.Scala 3 is a new version of a beloved functional hybrid language, one with many improvements over Scala 2. This course has been completely re-written for Scala 3, to introduce the new features, concepts, keywords and syntax. In addition the course exercises have been fully updated and brought to Visual Studio Code and Metals (the meta-language-server) for the hands-on portions of the course.This course is half theory and half practice. Each subject covered includes worksheet based examples that you can experiment with, and exercises to complete allowing you to practice and reinforce what you have just learned in the theory.The concepts are taught in a straightforward, simple approach with plenty of coding examples and clear explanations. Your instructor has more than 15 years of experience in Scala programming and more than a dozen years of experience teaching Scala to others. Scala 3, just what you need, takes its title from two ideas, that the Scala 3 language could be just what you need to solve your programming problems, and that the topics covered are just what you need to quickly become productive in the language while still learning a lot of the theory and best practices surrounding Scala programming.Come and learn Scala, at your own pace, from an experienced developer and trainer. Have fun while learning, and pick up the skills for using the tools and libraries as well as the core language.Topics covered include:Language and SyntaxControl StructuresClasses, Objects, TraitsFunctionsPattern MatchingCase Classes and EnumsPackages, Scopes and ImportingInheritance and Scala Type HierarchyTestingLists and CollectionsJava IntegrationUsing LibrariesBuilding Scala with SBTAsynchronous Programming with Futures

Overview

Section 1: Introduction to Scala 3

Lecture 1 Module 1 - Overview

Lecture 2 Module 1 - Agenda

Lecture 3 Module 1 - The Scala REPL

Lecture 4 Module 1 - SBT

Lecture 5 Module 1 - First Time in the REPL

Lecture 6 Module 1 - Vals and Vars

Lecture 7 Module 1 - Hiding Vals

Lecture 8 Module 1 - Scopes in the REPL

Lecture 9 Module 1 - Scala and Types

Lecture 10 Module 1 - Method/Function Definitions

Lecture 11 Module 1 - If Expressions

Lecture 12 Module 1 - Functional Style

Lecture 13 Module 1 - Try..Catch..Finally Expressions

Lecture 14 Module 1 - Simple Loops

Lecture 15 Module 1 - Do..While

Lecture 16 Module 1 - Using the Worksheet

Lecture 17 Module 1 - Exercises

Section 2: Next Steps with Scala 3

Lecture 18 Module 2 - Overview

Lecture 19 Module 2 - Agenda

Lecture 20 Module 2 - Scala Projects in VSCode

Lecture 21 Module 2 - Creating a Worksheet

Lecture 22 Module 2 - Method Parameters and Return Types

Lecture 23 Module 2 - Methods With No Return Types

Lecture 24 Module 2 - Expressions vs Statements

Lecture 25 Module 2 - Statements and Expressions

Lecture 26 Module 2 - Tuples

Lecture 27 Module 2 - Tuples Continued

Lecture 28 Module 2 - Re-writing Rules, Infix

Lecture 29 Module 2 - Re-writing Rules, Apply

Lecture 30 Module 2 - Re-writing Rules, Update

Lecture 31 Module 2 - Re-writing Rules General Notes

Lecture 32 Module 2 - Quick Collections Intro

Lecture 33 Module 2 - List Initialization

Lecture 34 Module 2 - Sequences

Lecture 35 Module 2 - Sets

Lecture 36 Module 2 - (Im)mutability of Collections

Lecture 37 Module 2 - Maps

Lecture 38 Module 2 - The -> Extension Method

Lecture 39 Module 2 - Simple Map Iteration

Lecture 40 Module 2 - Mutability vs Functional Style

Lecture 41 Module 2 - Opening and Reading a File

Lecture 42 Module 2 - Exercises

Section 3: Classes and Objects

Lecture 43 Module 3 - Overview

Lecture 44 Module 3 - Agenda

Lecture 45 Module 3 - A Scala Class Definition

Lecture 46 Module 3 - Constructor

Lecture 47 Module 3 - Parameters, Fields and Parametric Fields

Lecture 48 Module 3 - A Rational Class

Lecture 49 Module 3 - Checking Preconditions

Lecture 50 Module 3 - Referencing self

Lecture 51 Module 3 - Infix and Symbolic Methods

Lecture 52 Module 3 - Infix and Symbolic Methods Continued

Lecture 53 Module 3 - Adding an Int to a Rational

Lecture 54 Module 3 - Companion Objects

Lecture 55 Module 3 - Because It's a Companion

Lecture 56 Module 3 - Adding an Int to a Rational, Again

Lecture 57 Module 3 - Adding a Rational to an Int

Lecture 58 Module 3 - Implicits

Lecture 59 Module 3 - Application Objects

Lecture 60 Module 3 - Exercises

Section 4: Control Structures

Lecture 61 Module 4 - Overview

Lecture 62 Module 4 - Agenda

Lecture 63 Module 4 - Expressions vs Statements

Lecture 64 Module 4 - Unit

Lecture 65 Module 4 - Returning Something Other Than Unit

Lecture 66 Module 4 - Returning this instead of Unit

Lecture 67 Module 4 - Scala's if Expression

Lecture 68 Module 4 - val and var

Lecture 69 Module 4 - try … catch … finally

Lecture 70 Module 4 - While Loop

Lecture 71 Module 4 - For

Lecture 72 Module 4 - For … Yield

Lecture 73 Module 4 - The Four Gs of For

Lecture 74 Module 4 - For is More than just Loops

Lecture 75 Module 4 - Match Expressions

Lecture 76 Module 4 - Match Expression Guards

Lecture 77 Module 4 - Match and More Match

Lecture 78 Module 4 - String Interpolation

Lecture 79 Module 4 - Exercises

Section 5: Functions and Closures

Lecture 80 Module 5 - Overview

Lecture 81 Module 5 - Agenda

Lecture 82 Module 5 - Private Methods

Lecture 83 Module 5 - Nested Methods

Lecture 84 Module 5 - Nested Method Scoping

Lecture 85 Module 5 - Function Literals

Lecture 86 Module 5 - Using an Anonymous Function Literal

Lecture 87 Module 5 - How Function Literals Work

Lecture 88 Module 5 - Other Methods on Function

Lecture 89 Module 5 - Higher Order Functions

Lecture 90 Module 5 - Writing a Higher Order Function

Lecture 91 Module 5 - Placeholder Syntax

Lecture 92 Module 5 - Placeholders with Types

Lecture 93 Module 5 - Partial Application of Functions

Lecture 94 Module 5 - Partially Applying All Parameters

Lecture 95 Module 5 - Closures

Lecture 96 Module 5 - Partial Functions

Lecture 97 Module 5 - Partial Functions Continued

Lecture 98 Module 5 - Even More Partial Functions

Lecture 99 Module 5 - Var Args in Methods

Lecture 100 Module 5 - Var Args Continued

Lecture 101 Module 5 - Calling Var Args with a Collection

Lecture 102 Module 5 - Named and Default Parameters

Lecture 103 Module 5 - Couple with Default Parameters

Lecture 104 Module 5 - Exercises

Section 6: Custom Control Structures

Lecture 105 Module 6 - Overview

Lecture 106 Module 6 - Agenda

Lecture 107 Module 6 - Using the Contents of a File

Lecture 108 Module 6 - Using Generics and HoFs

Lecture 109 Module 6 - Calling the Generic Method

Lecture 110 Module 6 - Currying Revisited

Lecture 111 Module 6 - Currying in Methods

Lecture 112 Module 6 - Curried Generic Loan

Lecture 113 Module 6 - Function Arity

Lecture 114 Module 6 - Writing Our Own Loop

Lecture 115 Module 6 - By-name Functions

Section 7: Inheritance and Composition

Lecture 116 Module 7 - Overview

Lecture 117 Module 7 - Agenda

Lecture 118 Module 7 - Classes and Abstract Classes

Lecture 119 Module 7 - Abstract Classes

Lecture 120 Module 7 - Anonymous Classes and Overrides

Lecture 121 Module 7 - Uniform Access

Lecture 122 Module 7 - val, def, lazy val

Lecture 123 Module 7 - Inheriting and Extends

Lecture 124 Module 7 - Invoking Super-class Methods and Constructors

Lecture 125 Module 7 - Alternative Way to Define Car

Lecture 126 Module 7 - override Keyword

Lecture 127 Module 7 - override Continued

Lecture 128 Module 7 - final Keyword

Lecture 129 Module 7 - final Continued

Lecture 130 Module 7 - Final Classes

Lecture 131 Module 7 - Case Classes

Lecture 132 Module 7 - Domain Models

Lecture 133 Module 7 - Cars and Vehicles

Lecture 134 Module 7 - Parking Structure

Lecture 135 Module 7 - Now It's Your Turn

Section 8: Type Hierarchy, Optionals and Equality

Lecture 136 Module 8 - Overview

Lecture 137 Module 8 - Agenda

Lecture 138 Module 8 - Top Classes

Lecture 139 Module 8 - Top Types Example

Lecture 140 Module 8 - Organization from the Top

Lecture 141 Module 8 - Bottom Classes

Lecture 142 Module 8 - Null and Nothing

Lecture 143 Module 8 - Even More Nothing

Lecture 144 Module 8 - Scala Type Calculus (Simplified)

Lecture 145 Module 8 - Scala Type Inference Tricks

Lecture 146 Module 8 - Primitives and Implicit Conversions

Lecture 147 Module 8 - Rich Wrappers

Lecture 148 Module 8 - @specialized

Lecture 149 Module 8 - @specialized Generation

Lecture 150 Module 8 - Extension Methods and Implicit Classes

Lecture 151 Module 8 - Nil, Null, Nothing, None

Lecture 152 Module 8 - Option

Lecture 153 Module 8 - Working with Option

Lecture 154 Module 8 - Working with Option Continued

Lecture 155 Module 8 - Equals and Hashcode

Lecture 156 Module 8 - Option 1 - Use IDE

Lecture 157 Module 8 - Option 2 - Follow this Formula

Lecture 158 Module 8 - Option 2 Continued - Sub-classes

Lecture 159 Module 8 - Option 3 - Just Use Case Classes

Lecture 160 Module 8 - Multiversal Equality

Lecture 161 Module 8 - Product Types

Lecture 162 Module 8 - Product Type Features

Lecture 163 Module 8 - Exercises

Section 9: Traits

Lecture 164 Module 9 - Overview

Lecture 165 Module 9 - Agenda

Lecture 166 Module 9 - Multiple Inheritance

Lecture 167 Module 9 - Traits Compared to Interfaces

Lecture 168 Module 9 - Creating a Trait

Lecture 169 Module 9 - Using a Trait in a Class

Lecture 170 Module 9 - Polymorphism and Rich Interfaces

Lecture 171 Module 9 - Multiple Traits

Lecture 172 Module 9 - How'd it do that?

Lecture 173 Module 9 - Stacking Traits

Lecture 174 Module 9 - Stacking Traits - Quiz

Lecture 175 Module 9 - Stacking Traits - 1

Lecture 176 Module 9 - Stacking Traits - 2

Lecture 177 Module 9 - Stacking Traits - 3

Lecture 178 Module 9 - Trait Parameters - Scala 3

Lecture 179 Module 9 - Construction Composition

Lecture 180 Module 9 - abstract override

Lecture 181 Module 9 - Implementing the Abstract

Lecture 182 Module 9 - Traits with Type Parameters

Lecture 183 Module 9 - Another CompareAge Class

Lecture 184 Module 9 - Selfless Traits

Lecture 185 Module 9 - Exercises

Section 10: Packages, Imports and Scope

Lecture 186 Module 10 - Overview

Lecture 187 Module 10 - Agenda

Lecture 188 Module 10 - Public, Protected and Private

Lecture 189 Module 10 - Packages

Lecture 190 Module 10 - Package Structure Alternatives

Lecture 191 Module 10 - Namespace Notation

Lecture 192 Module 10 - More Parts of the Model

Lecture 193 Module 10 - Package Visibility

Lecture 194 Module 10 - Reaching the Top

Lecture 195 Module 10 - Now for Some Wine

Lecture 196 Module 10 - The PairWine Object

Lecture 197 Module 10 - Package Objects

Lecture 198 Module 10 - Importing from an Object

Lecture 199 Module 10 - Importing from an Instance

Lecture 200 Module 10 - Renaming Imports

Lecture 201 Module 10 - Selective Importing

Lecture 202 Module 10 - Companion Objects

Lecture 203 Module 10 - Exercises

Section 11: Testing

Lecture 204 Module 11 - Overview

Lecture 205 Module 11 - Agenda

Lecture 206 Module 11 - Pre and Post Conditions

Lecture 207 Module 11 - assert and assume Can Be Elided

Lecture 208 Module 11 - Requirements

Lecture 209 Module 11 - Testing

Lecture 210 Module 11 - Scalatest

Lecture 211 Module 11 - FunSuite

Lecture 212 Module 11 - FunSpec

Lecture 213 Module 11 - Matchers

Lecture 214 Module 11 - Matchers Continued

Lecture 215 Module 11 - More Matchers

Lecture 216 Module 11 - Unit vs Integration Testing

Lecture 217 Module 11 - Mocking Objects

Lecture 218 Module 11 - Unit Testing with Mocks

Lecture 219 Module 11 - Advantages of Mocks

Lecture 220 Module 11 - Fakes

Lecture 221 Module 11 - Property Driven Testing

Lecture 222 Module 11 - Custom Property Generators

Lecture 223 Module 11 - Testing with Futures

Lecture 224 Module 11 - Waiting for the Future

Lecture 225 Module 11 - whenReady

Lecture 226 Module 11 - Async Suites

Lecture 227 Module 11 - Exercises

Section 12: Pattern Matching

Lecture 228 Module 12 - Overview

Lecture 229 Module 12 - Agenda

Lecture 230 Module 12 - Simple Constant Patterns

Lecture 231 Module 12 - match is an Expression

Lecture 232 Module 12 - Variable Loads

Lecture 233 Module 12 - Binding vs Loading

Lecture 234 Module 12 - Case Matters!

Lecture 235 Module 12 - But!

Lecture 236 Module 12 - Guards

Lecture 237 Module 12 - The Wrong Way to Guard

Lecture 238 Module 12 - Matching Options

Lecture 239 Module 12 - Matching Tuples

Lecture 240 Module 12 - Matching Lists

Lecture 241 Module 12 - Other Collections

Lecture 242 Module 12 - Matching Try

Lecture 243 Module 12 - Case Classes

Lecture 244 Module 12 - Case Classes Continued

Lecture 245 Module 12 - Case Classes, Copying

Lecture 246 Module 12 - Compound Pattern Matches

Lecture 247 Module 12 - Typed Pattern Matches

Lecture 248 Module 12 - Beware Type Erasure

Lecture 249 Module 12 - val and Pattern Matching

Lecture 250 Module 12 - for and Pattern Matching

Lecture 251 Module 12 - Partial Functions and Pattern Matches

Lecture 252 Module 12 - Sealed Class Hierarchies

Lecture 253 Module 12 - Enums

Lecture 254 Module 12 - Enum Notes

Lecture 255 Module 12 - Enums with Parameters

Lecture 256 Module 12 - Extractors and Unapply

Lecture 257 Module 12 - Custom Extractors

Lecture 258 Module 12 - Custom Seq Extractors

Lecture 259 Module 12 - Exercises

Section 13: Collections 1: Lists

Lecture 260 Module 13 - Overview

Lecture 261 Module 13 - Agenda

Lecture 262 Module 13 - The Immutable Linked List

Lecture 263 Module 13 - List Properties

Lecture 264 Module 13 - Initializing Lists

Lecture 265 Module 13 - Converting to Lists

Lecture 266 Module 13 - List is Covariant

Lecture 267 Module 13 - Constant Time Operations

Lecture 268 Module 13 - Linear Time Operations

Lecture 269 Module 13 - Operations that Depend on Position

Lecture 270 Module 13 - Higher Order Functions

Lecture 271 Module 13 - Predicate Based Functions

Lecture 272 Module 13 - Folds

Lecture 273 Module 13 - Fold Alternatives

Lecture 274 Module 13 - Sorting

Lecture 275 Module 13 - Even More Functions

Lecture 276 Module 13 - Even More Functions Continued

Lecture 277 Module 13 - Permutations and Combinations

Lecture 278 Module 13 - Indices, zip, unzip

Lecture 279 Module 13 - Exercises

Section 14: Collections 2: The Rest

Lecture 280 Module 14 - Overview

Lecture 281 Module 14 - Agenda

Lecture 282 Module 14 - Other Collections

Lecture 283 Module 14 - Sequences Performance

Lecture 284 Module 14 - Sets and Maps Performance

Lecture 285 Module 14 - LinearSeq vs IndexedSeq

Lecture 286 Module 14 - mutable vs immutable

Lecture 287 Module 14 - Consistent API

Lecture 288 Module 14 - Easy Conversions

Lecture 289 Module 14 - Other Sequences

Lecture 290 Module 14 - The Mighty Vector

Lecture 291 Module 14 - The Might Vector Continued

Lecture 292 Module 14 - Sets (immutable)

Lecture 293 Module 14 - Sorted and Mutable Sets

Lecture 294 Module 14 - Maps

Lecture 295 Module 14 - Sorted and Mutable Maps

Lecture 296 Module 14 - Maps - Key and Value Operations

Lecture 297 Module 14 - Concrete Implementations, immutable

Lecture 298 Module 14 - Concrete Implementations, mutable

Lecture 299 Module 14 - Iterators

Lecture 300 Module 14 - Views

Lecture 301 Module 14 - LazyList

Lecture 302 Module 14 - Exercises

Section 15: Scala Builds and Java Compatibility

Lecture 303 Module 15 - Overview

Lecture 304 Module 15 - Agenda

Lecture 305 Module 15 - Scala Build Tools

Lecture 306 Module 15 - SBT

Lecture 307 Module 15 - Using SBT

Lecture 308 Module 15 - SBT Project Source Layout

Lecture 309 Module 15 - build.sbt

Lecture 310 Module 15 - Example build.sbt

Lecture 311 Module 15 - Example plugins.sbt

Lecture 312 Module 15 - Making a Custom Setting

Lecture 313 Module 15 - And a Custom Task

Lecture 314 Module 15 - Multiple Project Support

Lecture 315 Module 15 - Mixing Scala and Java

Lecture 316 Module 15 - Scala/Java Compile Cycle

Lecture 317 Module 15 - Calling Java from Scala

Lecture 318 Module 15 - Scala 3 and Java

Lecture 319 Module 15 - Java 8+ / Scala 3 Function Compatibility

Lecture 320 Module 15 - Handling Nulls

Lecture 321 Module 15 - Options to Nulls

Lecture 322 Module 15 - Java -> Scala Collections

Lecture 323 Module 15 - Boxed Types Trouble

Lecture 324 Module 15 - Scala Traits and Java Interfaces

Lecture 325 Module 15 - General Advice

Lecture 326 Module 15 - Exercises

Section 16: Asynchronous Programming with Futures

Lecture 327 Module 16 - Overview

Lecture 328 Module 16 - Agenda

Lecture 329 Module 16 - Futures

Lecture 330 Module 16 - Creating a Future

Lecture 331 Module 16 - Some Initial Rules

Lecture 332 Module 16 - Future States

Lecture 333 Module 16 - Composing Futures

Lecture 334 Module 16 - Futures with for

Lecture 335 Module 16 - Async Evaluation

Lecture 336 Module 16 - Forcing a Result

Lecture 337 Module 16 - Other Future Operations

Lecture 338 Module 16 - More Operations

Lecture 339 Module 16 - Recovering from Failures

Lecture 340 Module 16 - Dealing with Multiple Futures

Lecture 341 Module 16 - Other Future Sequence Operations

Lecture 342 Module 16 - Promises

Lecture 343 Module 16 - A Broken Promise

Lecture 344 Module 16 - Working with Java's Futures

Lecture 345 Module 16 - Future Patterns - Batching

Lecture 346 Module 16 - Future Batching - foldLeft and flatMap

Lecture 347 Module 16 - Future Patterns - Retrying

Lecture 348 Module 16 - Retrying Futures (naive)

Lecture 349 Module 16 - Retrying Futures (loop)

Lecture 350 Module 16 - Retrying with Back-off

Lecture 351 Module 16 - Retrying with Back-off - In Use

Lecture 352 Module 16 - Exercises and Congratulations

This is a course for programmers looking to learn Scala, and in particular Scala 3. It assumes no knowledge of Scala 3, but does assume that you understand basic programming principles like conditionals and loops. We'll teach you the rest.