Scala Language Fundamentals


Scala Language Fundamentals

Authors: Harit Himanshu, Janani Ravi, Toby Weston, Vikash Sharma

Scala (/ˈskɑːlɑː/ SKAH-lah) combines object-oriented and functional programming in one concise, high-level language. Scala's static types help avoid bugs in complex

  • LinkedIn
  • Twitter
  • Netflix
  • Tumblr
  • Foursquare
  • AirBnB
By the end of this path, learners will have the foundation needed to begin building applications using the Scala Language as well as the tools needed for best practices.. ... Read more

  • The capabilities of the Scala Language
  • Preparing the Scala Development Environment
  • Data types and variables in Scala
  • Writing and using statements, control structures, methods, functions, objects, and classes in Scala
  • Using the Scala Build Tool (SBT) to compile Scala applications
  • Unit testing
  • Anschy programming
  • other important methodoligies to prepare the learner in using the Scala language to its full capabilities


Intermediate knowledge of a procedural programming language such as Java, C#, or C


These introductory Scala courses will teach you the basics of how to effectively work with the Scala language. Get started by setting up the development environment and discovering the overall capabilities of the Scala language.

Scala Language: The Big Picture

by Harit Himanshu

Aug 13, 2020 / 40m


Start Course

It is intimidating when you are not sure if a programming language can help you solve your problems at hand. In this course, Scala Language: The Big Picture, you’ll learn to get started with the language. First, you’ll explore the language and the entire ecosystem developed using tools and libraries. Next, you’ll discover how Scala code is structured and executed. Finally, you’ll learn how to integrate Java code with Scala and run them together. When you’re finished with this course, you’ll have the skills and knowledge of Scala needed to take next steps of diving deeper and learning the fundamentals of the language.

Table of contents
  1. Course Overview
  2. Understanding the Scala Ecosystem
  3. Learning the Language Details

Scala Language: Getting Started

by Harit Himanshu

Feb 5, 2021 / 2h 2m

2h 2m

Start Course

Imagine you have a need or desire to learn Scala and you have seen a lot of documentation but are still confused as to where to start. Your search ends here. In this course, Scala Language: Getting Started, you’ll learn to apply the fundamental concepts of the language in a practical manner. First, you’ll explore the concepts such as variables, types, and values. Next, you’ll discover how expressions and control structures work in Scala. Then, you will see Pattern Matching while working on real-world problems. Next, you will explore functions and method and see how to create and execute your own functions. Finally, you’ll learn how to apply these concepts as a standalone program and run it on the command-line. When you’re finished with this course, you’ll have the skills and knowledge of Scala Language needed to start creating your own Scala programs with confidence.

Table of contents
  1. Course Overview
  2. Installing Scala on Your Machine
  3. Getting Started with REPL
  4. Working with Variables and Basic Types
  5. Working with Control Structures
  6. Working with Pattern Matching
  7. Working with Methods, Functions, and Implicit Conversions
  8. Packaging and Executing Scala Code


Continue learning the Scala language in this section that will take the fundamentals of Scala and expand to writing methods, functions, and creating collections using Scala.

Scala Methods and Functions

by Janani Ravi

Aug 19, 2020 / 3h 15m

3h 15m

Start Course

Working with Big Data these days increasingly requires an understanding of functional programming constructs, because of how easily functional code can be distributed. Scala is a general-purpose programming language that runs on the JVM and supports both functional and object-oriented programming paradigms.

In this course, Scala Methods and Functions, you’ll learn to utilize those aspects of Scala that are specific to the functional programming paradigm.

First, you'll see how variables with different type modifiers are assigned and evaluated and you’ll understand the differences between Scala val, var, lazy val, and def keywords.

Next, you’ll discover the attributes of first-class functions, and the use of higher-order functions and partial functions in order to simplify code design.

Next, you’ll learn how to harness the power of features for Scala methods such as currying, recursion, named and positional arguments, and varargs.

Finally, you'll learn how to deal with missing values and errors in Scala and work with functional error handling idioms such as Try-Success-Failure, Option-Some-None, and Either-Right-Left.

When you’re finished with this course, you’ll have the skills and knowledge of functions and methods in Scala needed to write correct, concise, yet easily understandable code that combines the power of the functional programming paradigm with a strong static type system.

Table of contents
  1. Course Overview
  2. Getting Started with Functions and Methods
  3. Understanding and Implementing Functions
  4. Understanding and Implementing Methods
  5. Dealing with Exceptions and Missing Values

Scala Collections

by Toby Weston

Dec 23, 2020 / 1h 59m

1h 59m

Start Course

If you’re a programmer targeting the JVM, you'll be familiar with Java and its collection types. In this course, Scala Collections, you'll learn about Scala's power and its collections that will help your next application. First, you'll discover Scala lists and how to find elements in them. Next, you'll explore collection types and how to choose which is right for you. Finally, you'll learn how to transform elements and simplify complex computations. When you're finished with this course, you'll have the knowledge required to use Scala's collections and some of the functional programming idioms that power them.

Table of contents
  1. Course Overview
  2. Creating and Using Scala's Lists
  3. Finding Elements in a List
  4. Save Overheads with Tuples
  5. Selecting the Right Collection Type
  6. Converting between Java and Scala
  7. Transforming Elements
  8. Simplify Complex Computations with Monads

Coming Soon

Scala Classes and Objects

Coming Soon

by Harit Himanshu

Scala Build Tool: Getting Started

by Harit Himanshu

Jun 13, 2019 / 1h 37m

1h 37m

Start Course

This course is well suited for software developers who are working or planning to contribute to a Scala codebase. Scala Build Tool (sbt) is a widely accepted Build Tool in the Scala Ecosystem, and the Scala language codebase itself is built and shipped with sbt. This course, Scala Build Tool: Getting Started, starts from the basics of working with the sbt shell; you'll learn about settings, tasks, scopes, build definition, multi-module builds, plugins, and working with 3rd party libraries. You will explore how to create a project from scratch, and add source files and tests. Next, you will discover how to compile and test your source code. Finally, you'll examine how to open-source your work in this project and deploy the executable API for anyone in the world to use. After taking this course, you will know the ins and outs of sbt, and will be comfortable starting or refactoring the codebases you work with.

Table of contents
  1. Course Overview
  2. Introduction to sbt
  3. sbt Fundamentals
  4. Project Lifecycle Using sbt
  5. Refactoring the Project for Bigger Changes
  6. Open-sourcing the Project


For the learner that has a grasp on the Scala language and looking to learn the finer points of asynchronous programming, type classes, and unit testing for Scala. By the end of this section, you will be prepared to create robust Scala applications.

Scala Asynchronous Programming

by Vikash Sharma

Oct 14, 2020 / 1h 28m

1h 28m

Start Course

A good software system should be performant, scalable, and efficient. Along with infrastructure, it depends a lot on the way it’s written. In the course, Scala Asynchronous Programming, you’ll learn how to achieve better performance and scalability by non-blocking and asynchronous code. First, you’ll discover why blocking is not the way to go, you’ll understand why it’s important to write asynchronous code. Then, you’ll explore one of the high level abstractions for writing async code i.e. Scala Futures. By the end of the course, you’ll learn to create Scala Futures and how to handle successful and failed future values.

Finally, you’ll learn about the actor model and how it can be used to write async message based systems. You’ll learn the basics of using Akka’s actor model, along with writing message protocols, async communication, supervision strategy. You’ll learn how a shared mutable state is handled in Actors. You’ll also get a basic understanding about routing, mailbox and dispatcher.

By the end of this course, you’ll have the knowledge to use Scala Futures or Actor Model for writing scalable and performant software systems.

Table of contents
  1. Course Overview
  2. Why Asynchronous Programming
  3. Going Async with Scala Futures
  4. Actor Model for Async Communication
  5. Supervision Strategy for Handling Failovers & Configuring ActorSystem

Unit Testing in Scala

by Harit Himanshu

Jan 21, 2020 / 2h 24m

2h 24m

Start Course

ScalaTest is a popular choice to test Scala projects. It has been used by well-known open-source projects such as Akka. In this course, Unit Testing in Scala, you will learn how to test a Scala project using ScalaTest. First, you will test your codebase using Assertions and Matchers. Next, you will discover how to create Fixtures for your testing using various methods, and how to test for asynchronous code. Then, you will see how to mock complex object creation and test for behaviors, while also learning to create tags and apply them selectively to your tests so that you can run tests based on the tags. Finally, you will explore different ways of running a test written using ScalaTest library. When you are finished with this course, you will have all the required knowledge to plug ScalaTest into your projects and start testing with confidence.

Table of contents
  1. Course Overview
  2. Setting up the Project
  3. Writing the First Test
  4. Working with Assertions
  5. Performing Expressive Testing Using Matchers
  6. Generating Data through Fixtures and Asynchronous Testing
  7. Mocking and Tagging Your Tests

Scala Type Classes and Parameterization

by Vikash Sharma

Feb 10, 2021 / 1h 30m

1h 30m

Start Course

Writing software gets easier when types drive your software development, and utilizing static typing can ensure an easier way to write concise and type-safe code. In this course, Scala Type Classes and Parameterization, you’ll learn to use Scala's extensive generic programming constructs to write type-safe, abstract, and concise code. First, you’ll develop an understanding of what code abstraction and type-safety really means in software development. Next, you’ll discover parameterization in Scala and how they are implemented using parameterized and abstract types, along with how to implement generic methods. Then, you'll learn about the concepts of type bounds and variance. Finally, you’ll explore implicits in Scala and use them in writing typeclasses. When you’re finished with this course, you’ll have the skills and knowledge of Scala's extensive static type system needed to write abstract as well as easy to understand code.

Table of contents
  1. Course Overview
  2. Type Parameterization
  3. Methods with Type Parameters
  4. Type Bounds and Variance
  5. Implicits: Why, What, and How
  6. Typeclass: Ad Hoc Polymorphism

Scala Specific Design Patterns

by Vikash Sharma

Jan 23, 2020 / 1h 16m

1h 16m

Start Course

Writing real world applications using Scala requires the ability to write well-structured and easy to understand code. Often this can be achieved using a well-defined design pattern. In the course, Scala Specific Design Patterns, you'll learn to use such design patterns in order to create your own well-structured Scala applications. First, you'll explore how to use Typeclass pattern and Cake pattern. Next, you'll discover how to lazily evaluate expressions. Finally, you’ll dive into the concepts of Lens, Implicits Injection, and Memoization patterns. When you’re finished with the course, you’ll have the necessary knowledge of design patterns needed to understand how, when, and why to use them.

Table of contents
  1. Course Overview
  2. Scope and Purpose of Design Patterns
  3. Achieving Abstraction Using the Typeclass Pattern
  4. Using Cake Pattern for Dependency Injection
  5. Optimizing Performance by Lazy Evaluation
  6. Overcoming Immutability Limitations Using Lens Pattern
  7. Using Scala Implicits for Dependency Injection
  8. Understanding and Using Memoization Pattern
Offer Code *
Email * First name * Last name *
Country *

* Required field

Opt in for the latest promotions and events. You may unsubscribe at any time. Privacy Policy

By providing my phone number to Pluralsight and toggling this feature on, I agree and acknowledge that Pluralsight may use that number to contact me for marketing purposes, including using autodialed or pre-recorded calls and text messages. I understand that consent is not required as a condition of purchase from Pluralsight.

By activating this benefit, you agree to abide by Pluralsight's terms of use and privacy policy.

I agree, activate benefit