Scala Applied, Part 3
4.7 (235 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,159 students enrolled

Scala Applied, Part 3

Part 3 of Scala Applied, covering Scala's core libraries
4.7 (235 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,159 students enrolled
Created by Dick Wall
Last updated 2/2019
English
English [Auto]
Price: $19.99
30-Day Money-Back Guarantee
This course includes
  • 5.5 hours on-demand video
  • 1 article
  • 2 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
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
Course content
Expand all 126 lectures 05:22:10
+ Course Introduction and Exercises
2 lectures 02:00

This is part three of a three part course, the first part covers converting to Scala from other programming languages and part two covers Scala language features that might be different from other languages or perhaps even unique. This part three finishes the tour of powerful language features with case classes and pattern matching, then moves on to the most important core library features, like collections, futures, and also covers building and working with Java.

Slides and exercises are attached to the next lecture.

Preview 01:44
Download Slides and Exercises
00:16
+ Module 12 - Pattern Matching
29 lectures 01:13:30
09 - Guards
02:49
10 - The Wrong Way to Guard
02:04
11 - Matching Options
02:41
12 - Matching Tuples
02:52
13 - Matching Lists
03:11
14 - Other Collections
02:51
15 - Matching Try
01:57
16 - Case Classes 1
02:20
17 - Case Classes 2
01:59
18 - Case Classes 3
02:10
19 - Compound Pattern Matches
02:16
20 - Typed Pattern Matches
02:58
21 - Beware Type Erasure!
06:21
22 - val and Pattern Matching
03:23
23 - for and Pattern Matching
02:57
24 - Partial Functions and Pattern Matches
01:46
25 - Sealed Class Hierarchies
03:17
26 - Extractors and unapply
02:32
27 - Custom Extractors
02:50
28 - Custom Seq Extractors
01:59
29 - Module 12 Exercises
02:08
Case Classes and Pattern Matching
7 questions
+ Module 13 - Lists
20 lectures 56:26
03 - The Immutable Linked List
04:34
04 - List Properties
03:24
05 - Initializing Lists
02:09
06 - Converting to Lists
01:28
07 - List is Covariant
01:07
08 - Constant Time Operations
01:53
09 - Linear Time Operations
02:17
10 - Operations that Depend on Position
03:32
11 - Higher Order Functions
02:52
12 - Predicate Based Functions
02:57
13 - Folds
07:05
14 - Fold Alternatives
01:53
15 - Sorting
05:39
16 - Even More Functions
03:09
17 - And More
02:41
18 - Permutations and Combinations
03:29
19 - Indices, zip, unzip
02:29
20 - Module 13 Exercises
01:53
Working with Lists
5 questions
+ Module 14 - Collections
23 lectures 54:35
03 - Other Collections
01:07
04 - Sequences Performance
03:56
05 - Sets and Maps Performance
02:02
06 - LinearSeq vs IndexedSeq
02:08
07 - mutable vs immutable
02:45
08 - Consistent API
03:21
09 - Easy Conversions
02:17
10 - Other Sequences
02:07
11 - The Mighty Vector
03:59
12 - Vector (continued)
01:13
13 - Immutable Sets
03:44
14 - Sorted and Mutable Sets
02:10
15 - Maps
03:43
16 - Sorted and Mutable Maps
00:50
17 - Key and Value Operations
03:12
18 - Immutable Implementations
01:49
19 - Mutable Implementations
01:03
20 - Iterators
02:15
21 - Views
02:21
22 - Streams
05:57
23 - Module 14 Exercises
00:59
Collections
6 questions
+ Module 15 - Building Scala, SBT, Java Compatibility
26 lectures 56:47
03 - Maven
01:23
04 - Gradle
00:33
05 - Other Options
00:44
06 - SBT
01:40
07 - Using SBT
09:14
08 - SBT Project Source Layout
02:17
09 - build.sbt
02:06
10 - Example build.sbt
04:16
11 - Example plugins.sbt
01:31
12 - Making a Custom Setting
03:31
13 - A Custom Task
01:37
14 - Multiple Project Support
03:48
15 - Mixing Scala and Java
01:58
16 - Scala/Java Compile Cycle
01:12
17 - Calling Java from Scala
03:25
18 - Scala 2.12 and Java 8
01:15
19 - Scala/Java Function Compatibility
01:59
20 - Handling Nulls
01:31
21 - Options to Nulls
00:44
22 - Java -> Scala Collections
02:57
23 - Boxed Types Trouble
02:09
24 - Scala Traits and Java Interfaces
01:36
25 - General Advice
01:30
26 - Module 15 Exercises
01:22
Build tools and integrating with Java
5 questions
+ Module 16 - Futures
26 lectures 01:18:52
03 - Futures
02:24
04 - Creating a Future
03:17
05 - Some Initial Rules
02:58
06 - Future States
07:06
07 - Composing Futures
02:01
08 - Futures with for
05:48
09 - Async Evaluation
00:33
10 - Forcing a Result
04:11
11 - Other Future Operations
05:16
12 - More Operations
02:32
13 - Recovering from Failures
02:50
14 - Dealing with Multiple Futures
04:38
15 - Other Future Sequence Operations
01:30
16 - Promises
03:14
17 - A Broken Promise
00:55
18 - Working with Java's Futures
01:16
19 - Future Patterns - Batching
04:07
20 - foldLeft and flatMap
04:59
21 - Future Patterns - Retrying
01:38
22 - Retrying (naive)
01:54
23 - Retrying (loop)
04:17
24 - Retrying with Back-off
04:57
25 - Retrying with Back-off 2
01:26
26 - Future Alternatives
03:01
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.

Who this course is for:
  • 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