Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add Stairway to Scala Applied, Part 3 to your Wishlist.

Add to Wishlist

Stairway to Scala Applied, Part 3

Part 3 of Stairway to Scala, covering Scala's core libraries
4.3 (3 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
29 students enrolled
Created by Dick Wall
Last updated 4/2016
English
$50
30-Day Money-Back Guarantee
Includes:
  • 5.5 hours on-demand video
  • 1 Article
  • 144 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?
What Will I Learn?
Use case classes to get lots of free, best practice functionality
Contruct pattern matches like a Scala pro
Create and use PartialFunctions
Use Akka to create and use Actors
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 and/or activator
Write custom tasks and settings in sbt
View Curriculum
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

Stairway to 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.

Following that we look at the Futures api in the core libraries and Actors using the Akka library. 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.

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 is the target audience?
  • 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
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 144 Lectures Collapse All 144 Lectures 07:44:24
+
Course Introduction and Exercises
1 Lecture 01:44

Please download the exercises attached to this lecture and unzip them somewhere on your machine where you can find them later. Also, if you have not already done so, please follow the free course instructions at https://www.udemy.com/stairway-to-scala-setup-instructions/learn/#/ so that you are ready to run both the Scala REPL and the exercises.

Thanks and enjoy the course. 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, actors and also covers building and working with Java.

Preview 01:44
+
Case Classes and Pattern Matching
28 Lectures 01:06:39







Simplifying expressions
08:50

Wildcard patterns
01:33

Constant patterns
02:29

Variable patterns
01:25

Lower case variables, upper case constants
03:42

Constructor patterns
01:41

Sequence patterns
01:59

Sequence patterns, :: style
02:11

Tuple patterns
02:31

Typed patterns
02:14

Type check and cast (poor style)
02:24

Type erasure means more matches
03:01

Variable binding
03:46

Pattern guards
03:40

Pattern guard examples
01:24

Sealed classes
03:08

The Option type
05:09

Deconstructing Option
01:22

Patterns in variable definitions
01:14

Patterns in for expressions
01:31

Exercises for Flight 12
00:34

Case Classes and Pattern Matching
7 questions
+
Partial Functions and Actors
24 Lectures 47:35
Flight 13 Introduction
00:05

Flight 13 Goals
00:12

Partial functions
00:32

Conceptual partial function
02:27

Actual partial functions
02:26

Partial function literals
01:21

It really is a partial function
01:40

3-element list works, empty list does not
02:46

isDefinedAt
02:03

How it's compiled
01:13

An actor's act method
01:49

Start an actor with start()
00:42

Each actor runs independently
00:19

Independent actors
00:33

The actor method
00:30

Sending a message
03:20

An actor has an "inbox"
06:08

Including/Importing Akka
02:58

Creating an Akka Actor
02:58

Using the Actor
04:36

Back to the Future!
03:10

In the Future, everything will be better
03:25

I Never Promised You A Perfect Future
02:06

Exercises for Flight 13
00:16

Partial Functions and Actors
5 questions
+
Working with Lists
25 Lectures 01:10:33
Flight 14 Introduction
00:05

Flight 14 Goals
01:36

List literals
03:17

Lists are homogeneous and covariant
05:34

Constructing lists
01:27

Basic operations on lists
04:02

Insertion sort with head, tail, isEmpty
03:06

List patterns
01:36

Insertion sort with pattern matching
03:50

First-order methods on List
03:38

length, init, last
03:37

reverse, take, drop
02:06

apply, indices
01:15

zip, zipWithIndex, unzip
04:54

toString, mkString
01:37

Higher-order functions: map
03:06

flatMap
03:00

foreach
01:24

filter, partition, exists
02:52

find, takeWhile, dropWhile
01:17

Fold left concept
07:09

Fold left code
03:00

Fold right
01:03

sortWith
05:20

Exercises for Flight 14
00:42

Working with Lists
5 questions
+
Scala's Collections Library
37 Lectures 01:01:50
Flight 15 Introduction
00:05

Flight 15 Goal
00:22

Collections hierarchy
02:13

Mutability modeled with types
02:40

Consistent construction
02:49

Consistent equality
03:22

Consistent equality continued
01:40

Consistent toString
02:09

Consistent return types
01:10

Traversable: easy conversion
00:30

Traversable: easy conversion continued
00:54

Traversable : easy concatenation
01:00

Traversable: How do I collect elements mapped by a *partial* function?
01:03

Traversable: How do you partition into two collections according to a predicate?
01:07

Traversable: How do you group elements according to a function?
01:46

Iterable: grouping, sliding, zipping
06:06

Seq: apply and updated
01:37

Seq: apply and updated continued
00:40

Seq hierarchy
01:19

Buffers: updates, insertions, removals, appends
01:02

Sets
01:25

mutable.Set
03:14

Set hierarchy
01:15

Maps
01:00

mutable.Map
02:02

Concrete immutable collections
04:19

Concrete mutable collections
01:26

Mutable to immutable and back
00:49

Views
01:46

Views continued
01:56

Iterators
01:05

Seq Performance Characteristics
01:58

Set/Map Performance Characteristics
00:39

Java and Scala collections
01:58

Java and Scala collections continued
02:13

Scala-to-Java only conversions
00:35

Exercises for Flight 15
00:36

Collections
6 questions
+
Build Tools and Integrating with Java
29 Lectures 01:14:03
Introduction to Flight 16
00:07

Flight 16 Goals
00:40

Maven
01:55

Gradle
00:50

Other Options
01:11

SBT
01:12

Using sbt
09:34

sbt structure and requirements
03:09

build.sbt
05:20

example build.sbt
03:07

example plugins.sbt
01:29

Custom settings
02:56

Custom tasks
04:53

Multiple Projects
06:11

Activator
08:26

project/*.scala
01:48

Using Java Libraries
01:21

Scala / Java Compile Cycle
02:14

Calling Java from Scala
04:59

Java 8 Support coming in Scala 2.12
00:24

Nulls from Java
01:53

Nulls to Java
00:55

Working with Java Collections
02:28

Implicit conversions not always enough?
02:26

Using Java Interfaces/Inner Classes
01:27

Using Option from Java
00:56

Using Scala Objects/Traits in Java
00:49

General Advice
00:40

Exercises for Flight 16
00:43

Build tools and integrating with Java
7 questions
About the Instructor
3.8 Average rating
160 Reviews
2,348 Students
4 Courses
Scala Developer

Dick is a Scala Developer with over 8 years of Scala development experience, and over 6 years of Scala training experience. As well as consulting in Scala, Dick contributes to a number of open source Scala projects, libraries and tools, and is very active in the Scala developer community. He is also one of the Scalawags, a video podcast about the Scala language. Along with Bill Venners he runs Escalate Software which provides Scala training services.

Report Abuse