Scala Handbook

Scala is a statically typed language that mixes object-oriented and functional programming. Martin Odersky designed it at EPFL in Switzerland, and it was first released in 2004. Scala compiles to JVM bytecode, so a Scala program runs anywhere Java runs and can call any Java library directly — the whole Java ecosystem is available on day one.

What makes Scala feel different is how little ceremony it needs. Types are inferred, almost everything is an expression that returns a value, functions are values you pass around, and immutable data is the default. You get the safety of a strict compiler with code that often reads as short as Python.

• Data engineering — Apache Spark is written in Scala, and its Scala API is the most complete one. Spark jobs, Delta Lake and Iceberg pipelines, and Databricks notebooks are a large share of Scala jobs. See the Spark Scala functions handbook and the Data Engineering course.
• Streaming — Apache Kafka started life in Scala and its broker still has Scala code; Kafka Streams, Flink and Akka/Pekko Streams all have Scala APIs used in real-time pipelines.
• Backends — fintech, ad-tech and trading firms build high-throughput services with Play, http4s, ZIO, Cats Effect and Akka/Pekko.
• Compilers and tooling — Scala's type system makes it popular for DSLs, code generators and internal platforms.

Scala 3 (released 2021) is a rewrite of the compiler with a cleaner syntax. This handbook teaches Scala 3. You will still meet Scala 2.12 and 2.13 in the wild — Apache Spark is built on Scala 2.13 (and older clusters on 2.12) — so wherever the syntax differs, the lesson shows the Scala 2 form too. The good news: the concepts are the same, and most Scala 2 code compiles in Scala 3 unchanged.

The official installer is Coursier (cs). Its cs setup command installs a JDK if you do not have one, plus scala (the runner, which is scala-cli under the hood), scalac, sbt and scalafmt, and puts them on your PATH.

brew install coursier
coursier setup

# open a new terminal, then check
scala version

curl -fL https://github.com/coursier/coursier/releases/latest/download/cs-x86_64-pc-linux.gz | gzip -d > cs
chmod +x cs
./cs setup

# open a new terminal, then check
scala version

# download and unzip the Windows launcher
Invoke-WebRequest -Uri "https://github.com/coursier/coursier/releases/latest/download/cs-x86_64-pc-win32.zip" -OutFile cs.zip
Expand-Archive cs.zip -DestinationPath .
.\cs-x86_64-pc-win32.exe setup

# open a new terminal, then check
scala version

Scala code runner version: 1.16.0
Scala version (default): 3.9.0

What a working install prints (your version numbers may be newer).

For an editor, use IntelliJ IDEA with the Scala plugin, or VS Code with the Metals extension. Both understand sbt and scala-cli projects, show type hints and errors as you type, and run @main methods with one click.

Create a folder, save this as Main.scala, then run scala run Main.scala in that folder. The first run downloads the compiler, so it is slow; after that it takes a few seconds.

@main def hello(): Unit =
  println("Hello, Scala!")
  println(2 + 3)

Hello, Scala!
5

1. 1
   1. @main

   Marks hello as the program's entry point. The name is yours to choose — run, hello, app.

2. 2
   2. def hello(): Unit

   def defines a method. (): means it takes no parameters, and Unit is the return type — "returns nothing useful", like void in Java.

3. 3
   3. = and indentation

   The body follows =. In Scala 3 the indented lines under it are the body; no braces needed.

4. 4
   4. println

   Prints a value followed by a newline. It works with any type: strings, numbers, lists, your own classes.

scala run Main.scala     # compile (if changed) and run
scala compile Main.scala # compile only — shows errors
scala run .              # run every .scala file in the folder

What happens behind scala run: scala-cli compiles Main.scala to JVM bytecode in a hidden .scala-build folder, then starts a JVM and calls your @main method.

@main def run(): Unit =
  val age: Int = "42"
  println(age)

-- [E007] Type Mismatch Error: Main.scala:2:17
2 |  val age: Int = "42"
  |                 ^^^^
  |                 Found:    ("42" : String)
  |                 Required: Int
1 error found
Compilation failed

@main def run(): Unit =
  val age: Int = 42
  println(age)

A Scala 3 file can hold definitions at the top level: methods (def), values (val), classes, traits and objects. One method marked @main is where execution starts. Everything else is called from there.

// a top-level method: takes a name, returns a String
def greet(name: String): String =
  s"Hello, $name"

val language = "Scala"

@main def run(): Unit =
  println(greet("Priya"))
  println(greet(language))
  val total = 3 * 7
  println(s"3 * 7 = $total")

Hello, Priya
Hello, Scala
3 * 7 = 21

The same program in the Scala 2 style, which still compiles in Scala 3 and is what you will see in most Spark code: an object with a main method that receives the command-line arguments.

object Main {
  def greet(name: String): String = {
    s"Hello, $name"
  }

  def main(args: Array[String]): Unit = {
    println(greet("Priya"))
    println(s"args given: ${args.length}")
  }
}

Hello, Priya
args given: 0

The REPL

Type scala (or scala repl) with no file to open the REPL — a prompt that evaluates each line and prints its value and type. It is the fastest way to check what an expression does.

scala> val xs = List(1, 2, 3)
val xs: List[Int] = List(1, 2, 3)

scala> xs.map(_ * 10)
val res0: List[Int] = List(10, 20, 30)

scala> :quit

The REPL shows the inferred type of every value — a free lesson in type inference.

scala-cli (the scala command) is perfect for scripts, single files and learning. Library dependencies go in a comment directive at the top of the file:

//> using scala 3.3.6
//> using dep com.lihaoyi::os-lib:0.11.4

@main def run(): Unit =
  println(os.pwd)

sbt is the standard build tool for multi-file projects, libraries and Spark jobs. A project is a folder with a build.sbt and sources under src/main/scala; tests go in src/test/scala.

sbt new scala/scala3.g8   # scaffold a project (asks for a name)
cd hello-world
sbt run                   # compile and run
sbt test                  # run tests
sbt ~compile              # recompile on every save

ThisBuild / scalaVersion := "3.3.6"

lazy val root = project
  .in(file("."))
  .settings(
    name := "hello-world",
    libraryDependencies += "org.scalameta" %% "munit" % "1.0.0" % Test
  )

%% appends the Scala version to the artifact name (munit_3), because Scala libraries are published per Scala version. A Spark project sets scalaVersion to 2.13.x and adds "org.apache.spark" %% "spark-sql".

Scala has the same three comment styles as Java. // runs to the end of the line, /* ... */ spans lines, and /** ... */ is a Scaladoc comment that documentation tools and your IDE show as hover help.

/** Returns the area of a rectangle.
  * @param w width
  * @param h height
  */
def area(w: Int, h: Int): Int = w * h

@main def run(): Unit =
  // a single-line comment
  println(area(3, 4)) // can follow code too
  /* a block comment
     println("this never runs") */
  println("done")

12
done

Seventeen modules, each its own page, from your first val to a job-ready resume. The rail on the left lists them; the bar at the top and the pill at the bottom-left track your progress. A lesson ticks itself when you reach its end, and the tick survives closing the tab — no account needed.

• Examples are compiled and verified. Scala cannot run inside a web page, so every example here is a complete program that was compiled and run with real Scala 3 before publishing. The output under it is exactly what it printed — save it as Main.scala and run scala run Main.scala to see the same thing.
• "Your turn" tasks under each example ask you to change one thing. Predict the output first, then run it.
• Traces step through a program line by line with the values at each step — used for loops, recursion, pattern matching and folds.
• Error cards show the real scalac or JVM message, why it happened, and the fix. Module 11 collects the fifteen most common.
• Interview questions appear where the topic is taught and are collected in Module 15.
• The handbook ends with a certification exam (25 questions, 70% to pass), then the ATS resume checker with a real job posting.

An AI assistant will happily write a chain of map, flatMap and foldLeft for you. That is exactly why you should write them yourself while learning. The goal is the model in your head: what type each step returns, why a for-comprehension is just flatMap, why a match is exhaustive. That model is what an interviewer probes and what lets you debug a Spark job that failed at 3 a.m.

Ready? Module 01 starts with val and var, types, strings and reading keyboard input.