Skip to main content
CF

Scala & Functional Programming for Beginners | Rock the JVM

11h 21m 51s
English
Paid

Learn the basics of Scala and functional programming in a clear and hands-on way. You write real Scala code in small steps. You work through many short examples and exercises that help you build skill and confidence.

Why Learn Scala

Scala runs on the Java Virtual Machine. You can use it in many real projects. It also blends object‑oriented code with functional ideas, so you can write clear and safe programs.

  • You can use Scala in data tools like Spark and in backend systems with Akka and Play.
  • You can reuse your JVM knowledge while you learn a new style of coding.
  • You can write code that is short, strong, and easy to test.
  • You can join many teams that use Scala for data, backend work, or streaming jobs.

How the Course Works

You learn by writing code. Each idea comes with small steps and clear examples. You see how a concept works before you move on to the next one.

What You Practice

  • basic Scala syntax
  • functions and immutable data
  • pattern matching
  • collections and higher‑order functions
  • error handling with options and eithers
  • simple functional design

How Lessons Are Built

  • You learn one idea at a time.
  • You see each idea in working code.
  • You try small tasks that reinforce each topic.
  • You build larger code as you move forward.

Who Should Take This Course

This course is for developers who know at least one other language. You should understand core ideas like variables, loops, functions, memory, and how programs run. You do not need Java or Scala experience.

Requirements

  • basic skill in any programming language
  • comfort with computer science basics like memory and run time
  • Java is helpful but optional

What You Will Learn

  • read and understand Scala code in real projects
  • think in a functional style and write pure functions
  • build small and medium apps in Scala from scratch
  • join and contribute to open‑source Scala projects
  • prepare for tools built on Scala like Spark, Akka, and Play

Learning Approach

You get both theory and practice. Each lesson mixes ideas with code demos and tasks. You get space to try things, make mistakes, and fix them. This helps you build real skill, not just follow along.

Why This Works

  • You stay active by coding often.
  • You learn concepts in a clear order.
  • You build good habits early.
  • You see progress as you solve more tasks.

Final Notes

You get the most from this course when you stay focused and try every exercise. Work step by step, write lots of code, and enjoy the process. You will learn more by doing than by watching.

About the Author: Rock the JVM

Rock the JVM thumbnail

Rock the JVM (rockthejvm.com) is a Romania-based JVM-focused training platform run by Daniel Ciocîrlan — focused entirely on Scala, the broader JVM ecosystem, and the data-engineering / streaming stack built on top of it (Spark, Flink, Kafka). The platform is one of the most authoritative independent sources on Scala and functional programming on the JVM.

The CourseFlix listing carries four Rock the JVM courses: Scala & Functional Programming for Beginners, Cats (the Scala functional-programming library), Spark Streaming with Scala, and Apache Flink. The teaching style is unusually rigorous about the functional-programming fundamentals underneath the framework material.

Material is paid and aimed at engineers picking up Scala or building data-streaming systems on the JVM. For broader content, see CourseFlix's Scala, Java, and Messaging & Streaming category pages.

Watch Online 40 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 40 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Getting Started!
All Course Lessons (40)
#Lesson TitleDurationAccess
1
Getting Started! Demo
15:15
2
Values, Variables and Types
11:47
3
Expressions
19:35
4
Functions
21:53
5
Type Inference
04:22
6
Recursion
25:14
7
Call-by-Name and Call-by-Value
08:51
8
Default and Named Arguments
08:54
9
Smart Operations on Strings
15:09
10
Object-Oriented Basics
14:41
11
Object-Oriented Basics (exercises)
17:09
12
Syntactic Sugar: Method Notations
16:34
13
Method Notations (Exercises)
12:10
14
Scala Objects
15:38
15
Inheritance
16:41
16
Inheritance, Continued: Abstract Classes and Traits
11:48
17
Inheritance Exercises: Implementing Our Own Collection
15:50
18
Generics
26:03
19
Anonymous Classes
06:26
20
Object-Oriented Exercises: Expanding Our Collection
26:07
21
Case Classes
11:41
22
Scala 3: Enums
09:17
23
Exceptions
27:06
24
Packaging and Imports
12:42
25
What's a Function, Really?
23:01
26
Anonymous Functions
13:15
27
Higher-Order-Functions and Curries
19:39
28
HOFs and Curries (Exercises)
32:09
29
map, flatMap, filter and for-comprehensions
25:52
30
A Collections Overview
03:40
31
Sequences: List, Array, Vector
23:45
32
Tuples and Maps
15:33
33
Tuples and Maps (Exercises)
30:52
34
Options
26:20
35
Handling Failure
22:35
36
Pattern Matching
22:05
37
ALL the Patterns!
19:58
38
Patterns Everywhere
09:45
39
Scala 3: Braceless Syntax
20:12
40
What's next
02:17
Unlock unlimited learning

Get instant access to all 39 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites are required for this course?
To enroll in this course, you should be familiar with at least one programming language. Core concepts such as variables, loops, functions, and memory management should be well understood. No prior experience with Java or Scala is required, but a foundational understanding of how programs run will be beneficial.
What projects or tasks will I complete during the course?
Throughout the course, you will engage in small tasks and exercises that reinforce each topic. You will build larger pieces of code incrementally. Specific exercises include implementing your own collection, expanding collections, and handling errors using options and eithers. These practical tasks ensure you gain hands-on experience with Scala and functional programming concepts.
Who is the target audience for this course?
The course is designed for developers with knowledge of at least one programming language. It is particularly suitable for those interested in learning Scala to leverage its capabilities in data tools such as Spark or in backend systems with Akka and Play. This course is an ideal choice for developers looking to apply functional programming principles in practical environments.
How does the depth of this course compare to other Scala courses?
This course provides a clear and hands-on introduction to Scala and functional programming. It focuses on fundamental concepts such as basic Scala syntax, functions, immutable data, and pattern matching. While it covers essential topics like collections and error handling, it is intended as a beginner-level course. Advanced topics and comprehensive Scala projects might not be deeply explored here.
What specific tools or platforms will I learn about?
The course covers the Scala programming language and its applications on the Java Virtual Machine (JVM). You will learn about functional programming concepts that are applicable in data tools like Spark and backend systems such as Akka and Play. Additionally, Scala's integration with object-oriented programming is explored, offering a hybrid approach to coding.
What topics are not covered in this course?
While the course introduces basic Scala syntax and functional programming, it does not delve into advanced topics such as concurrency in Akka, deep integrations with Play framework, or detailed data processing using Spark. Additionally, the course does not provide extensive coverage of Scala's advanced features like macros or detailed performance optimizations.
What is the expected time commitment for this course?
The course consists of 40 lessons, each designed to be concise and focused. The exact runtime of the course is not specified, but the lessons are structured to be approachable and manageable, allowing you to learn at your own pace. Given the hands-on coding approach, the time commitment will vary based on individual practice and understanding of each topic.