History

How:
- Scala was created by Martin Odersky and was first released in 2003. It was designed to address the limitations of Java while running on the Java Virtual Machine (JVM), providing a modern language that supports both object-oriented and functional programming paradigms.
- Scala was developed to provide a language that could offer a concise and expressive syntax, while also being fully interoperable with Java, allowing Java developers to seamlessly integrate with Scala code.
- One of the key motivations behind Scala’s development was to offer better support for higher-order functions, immutable data, and concurrency, areas where Java was perceived to be lacking.
- Scala’s popularity grew rapidly, particularly in big data processing, web development, and reactive programming, largely due to its use in frameworks like Akka, Apache Spark, and Play Framework.
Who:
- Scala was designed by Martin Odersky, a computer science professor at EPFL (École polytechnique fédérale de Lausanne) in Switzerland, who previously contributed to the development of Java generics and was involved in the design of the Pizza programming language.
- The development of Scala is supported by Scala Center, and its ecosystem is maintained by the broader Scala community, with significant contributions from companies like Lightbend (formerly Typesafe) and individual developers worldwide.
Why:
- Scala was created to offer a more expressive, concise, and flexible language for developers who needed to write more readable and maintainable code, while still being able to leverage the existing Java ecosystem.
- The goal was to provide the scalability of Java combined with advanced language features like higher-order functions, immutable data, pattern matching, and a strong type system, which could be particularly useful in modern software engineering tasks such as distributed systems and big data.
- Scala also sought to offer better tools for concurrency, data processing, and reactive programming, which are crucial in today’s highly parallel and event-driven computing environments.

Introduction

Advantages

Multi-Paradigm — Seamlessly integrates Object-Oriented Programming (OOP) and Functional Programming (FP).
Concise Syntax — Massive reduction in boilerplate code compared to Java, utilizing type inference and high-level collections.
JVM Ecosystem Interop — Direct access to all Java libraries, frameworks, tools, and full bytecode compatibility.
Powerful Type System — Catch bugs at compile time with generic types, path-dependent types, structural typing, and type classes.
Excellent Concurrency Model — Safe multi-threading via Akka/Pekko Actor Model, Futures, and functional effect libraries (Cats Effect, ZIO).
Scala 3 Improvements — Cleaner syntax, type system improvements, and simpler contextual abstractions.

Disadvantages

Steep Learning Curve — Implicits, advanced type concepts (variance, higher-kinded types), and category theory patterns can be highly complex.
Compilation Times — Complex compiler analysis (type inference, macros, implicits resolution) results in slower compile times.
Binary Compatibility — Historically, major version upgrades (e.g. 2.12 to 2.13) broke binary compatibility, though Scala 3 has greatly improved this.
Small Job Market — Scala jobs are highly specialized and fewer in number compared to Java or Python.

Remember Points

Immutable by Default — Prefer val over var and immutable collections over mutable ones.
Expressions Everywhere — In Scala, almost everything (if, match, loops) is an expression returning a value.
Full Interoperability — Runs directly on JVM, fully compatible with existing Java codebases.

Basics

Hello World & Entry Point

// Scala 3 Main Entry Point
@main def hello(): Unit =
  println("Hello, World!")
  
// Scala 2 / Standard Object Entry Point
object Main {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }
}

@main declares a top-level runnable function in Scala 3.
Unit is equivalent to Java void / C++ void, representing no returning value.
object declares a Singleton instance in Scala.

Comments

// Single line comment
 
/* Multi-line
   comment block */
   
/** Scaladoc comment for documentation generation
  */

Variables and Constants

// val - Immutable constant (cannot be reassigned)
val name: String = "VR Rathod"
val age = 25 // type inferred as Int
 
// var - Mutable variable (can be reassigned)
var counter: Int = 0
counter += 1

Primitive Data Types (Any, AnyVal, AnyRef)

Class Hierarchy:
Any
├── AnyVal (Value Types)
│   ├── Double, Float
│   ├── Long, Int, Short, Byte
│   ├── Char, Boolean
│   └── Unit (behaves like void)
└── AnyRef (Reference Types / java.lang.Object)
    ├── String, List, UserDefinedClasses...
    └── Null (bottom type of AnyRef)

Nothing is the bottom type of the entire hierarchy (subclass of all types, has no values).

Type Inference

val x = 42 // Int
val y = 3.14 // Double
val message = "Hello" // String
 
// Types are checked statically, but compiler does the work
// val z: Int = "not an int" // Compile Error

Control Flow

If-Else as an Expression

// if/else statements return values in Scala
val age = 20
val status = if age >= 18 then "Adult" else "Minor"

Match Expression (Pattern Matching)

// Pattern matching on values
val number = 2
val word = number match {
  case 1 => "one"
  case 2 => "two"
  case _ => "many" // wildcard / default
}

Loops & For-Comprehensions

// 1. While Loop
var i = 0
while (i < 3) {
  println(i)
  i += 1
}
 
// 2. Standard For Loop (generators)
for (x <- 1 to 5) {
  println(x) // Prints 1 to 5 inclusive
}
 
// 3. For loop with guards & yield (Generates a new collection)
val evens = for {
  n <- 1 to 10
  if n % 2 == 0 // guard filter
} yield n * 2 // yields double value to Vector(4, 8, 12, 16, 20)

Breaks & Control Flow Exit

import scala.util.control.Breaks._
 
// Scala has no built-in break keyword, but can use Breaks class:
breakable {
  for (x <- 1 to 10) {
    if (x == 5) break() // exits breakable block
    println(x)
  }
}

Functions

Method Declaration

// def method_name(params): return_type = body
def add(a: Int, b: Int): Int = a + b
 
// Single parameter method (braceless in Scala 3)
def square(x: Int): Int = x * x

Named & Default Parameters

def greet(name: String, prefix: String = "Hello"): Unit =
  println(s"$prefix, $name!")
  
greet("VR") // Hello, VR!
greet(prefix = "Hi", name = "Alice") // Hi, Alice!

Anonymous Functions & Lambdas

val addLambda = (a: Int, b: Int) => a + b
 
// Shorthand syntax with underscores (positional arguments)
val nums = List(1, 2, 3)
val doubled = nums.map(_ * 2) // same as: nums.map(x => x * 2)

Higher-Order Functions

def calculate(x: Int, y: Int, op: (Int, Int) => Int): Int = op(x, y)
 
val sum = calculate(5, 10, _ + _) // 15

Currying & Partial Application

// Curried Method
def multiply(x: Int)(y: Int): Int = x * y
 
// Partially applied function
val doubleIt = multiply(2) // (y: Int) => 2 * y
print(doubleIt(5)) // 10

Tail Recursion (`@tailrec`)

import scala.annotation.tailrec
 
// Tail recursion optimized by compiler to avoid StackOverflowError
@tailrec
def sumList(list: List[Int], acc: Int = 0): Int = list match {
  case Nil          => acc
  case head :: tail => sumList(tail, acc + head)
}

OOP — Object-Oriented Programming

Classes & Constructors

// Primary constructor variables declared directly in class signature
class Person(val name: String, var age: Int) {
  // Constructor body
  println("Person initialized")
  
  // Auxiliary Constructor (overloaded constructor)
  def this(name: String) = this(name, 0)
}

Singleton & Companion Objects

// Scala has no 'static' keyword. Static members go into Singleton objects.
object DatabaseConnection {
  val url = "jdbc:mysql://localhost:3306"
  def connect(): Unit = println("Connected")
}
 
// Companion Object (same name as class, in same file)
class Circle(val radius: Double) {
  def area: Double = Circle.calculateArea(radius)
}
 
object Circle {
  private def calculateArea(r: Double): Double = Math.PI * r * r
}

Case Classes

// Case classes are immutable data containers. They auto-generate:
// constructor fields as public val, toString, equals, hashCode, copy methods, and unapply (pattern matching)
case class User(username: String, email: String)
 
val u1 = User("vr", "vr@example.com")
val u2 = u1.copy(email = "new@example.com") // copy values easily

OOP — Inheritance & Traits

Class Inheritance

class Employee(val id: Int)
 
class Manager(id: Int, val department: String) extends Employee(id) {
  override def toString = s"Manager $id for $department"
}

Traits & Mixin Composition

// Traits are similar to Java Interfaces, but can contain implementation code.
trait Speaker {
  def speak(): String // abstract
  def greet(): String = "Hello!" // concrete
}
 
trait Writer {
  def write(text: String): Unit = println(text)
}
 
// Mixin multiple traits using 'extends' and 'with'
class Author extends Speaker with Writer {
  def speak(): String = "Writing is speaking on paper."
}

Pattern Matching

Advanced Destructuring

sealed trait Notification
case class Email(sender: String, title: String) extends Notification
case class SMS(phone: String, message: String) extends Notification
 
def showNotification(note: Notification): String = note match {
  case Email(sender, title) if sender.endsWith("@org.com") => 
    s"Official email from $sender: $title"
  case Email(sender, title) => 
    s"Email from $sender: $title"
  case SMS(_, msg) => 
    s"SMS: $msg"
}

Contextual Abstractions (Scala 3)

Given Instances & Using Clauses

// Defines an implicit value of type String
given defaultGreeting: String = "Hello"
 
// Accepts the given parameter implicitly
def greetUser(name: String)(using greeting: String): Unit =
  println(s"$greeting, $name")
  
greetUser("Alice") // Implicitly pulls defaultGreeting -> "Hello, Alice"

Extension Methods

// Adding methods to existing classes without editing class code (type-safe)
extension (s: String)
  def toIntOrZero: Int = 
    try s.toInt catch { case _: NumberFormatException => 0 }
    
val raw = "123".toIntOrZero // 123

Generics (Variance & Bounds)

Variance annotations

// Covariant (+T) -> If A is subtype of B, Container[A] is subtype of Container[B]
class Box[+T](val value: T)
 
// Contravariant (-T) -> If A is subtype of B, Container[B] is subtype of Container[A]
class Serializer[-T]
 
// Invariant (T) -> Box[A] has no subclass relations to Box[B]
class StrictBox[T](var value: T)

Type Bounds

// Upper Bounds (T <: Animal) - restricts T to subtypes of Animal
class Vet[T <: Animal] {
  def treat(patient: T): Unit = println("Treating animal")
}
 
// Lower Bounds (T >: Dog) - restricts T to supertypes of Dog

Exception Handling

Try / Catch / Finally

import java.io.IOException
 
def loadConfig(): String = {
  try {
    // throw exception
    throw new IOException("Missing file")
  } catch {
    case e: IOException => "Loaded default configuration"
    case _: Exception => "Unknown error"
  } finally {
    println("Execution complete")
  }
}

Functional Error Abstractions

import scala.util.{Try, Success, Failure}
 
// 1. Try class - encapsulates exceptions as values
val result: Try[Int] = Try(10 / 0)
result match {
  case Success(v)  => println(s"Value: $v")
  case Failure(ex) => println(s"Failed with: ${ex.getMessage}")
}
 
// 2. Either class - Left represents failure, Right represents success
def divide(a: Int, b: Int): Either[String, Int] = {
  if (b == 0) Left("Division by zero")
  else Right(a / b)
}
 
// 3. Option class - Some(value) or None
val optVal: Option[String] = Some("Data")
val missingVal: Option[String] = None

Concurrency

Futures & Promises

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Success, Failure}
 
val computation: Future[Int] = Future {
  Thread.sleep(1000)
  42
}
 
computation.onComplete {
  case Success(value) => println(s"Answer: $value")
  case Failure(e)     => println(s"Task failed: ${e.getMessage}")
}

Collections

Immutable Collections

// Lists (linked list implementation)
val list = List(1, 2, 3)
val prepended = 0 :: list // List(0, 1, 2, 3)
 
// Vectors (fast indexed access)
val vec = Vector(1, 2, 3)
 
// Map
val map = Map("a" -> 1, "b" -> 2)
 
// Set
val set = Set("red", "blue")

Collections Transformations

val raw = List(1, 2, 3, 4, 5)
 
val squares = raw.map(x => x * x) // map
val evens = raw.filter(_ % 2 == 0) // filter
val sum = raw.foldLeft(0)(_ + _) // aggregate -> 15
 
// flatMap
val nested = List(List(1, 2), List(3, 4))
val flattened = nested.flatMap(x => x) // List(1, 2, 3, 4)

File I/O

Reading File contents

import scala.io.Source
import java.io.PrintWriter
import java.io.File
 
def main(args: Array[String]): Unit = {
  // Write to file
  val writer = new PrintWriter(new File("output.txt"))
  writer.write("Hello Scala File IO!")
  writer.close()
  
  // Read from file
  val source = Source.fromFile("output.txt")
  for (line <- source.getLines()) {
    println(line)
  }
  source.close() // Close source stream
}

Advanced Topics

Lazy Val (Lazy Initialization)

// Evaluated once, only when read for the first time
lazy val expensiveComputation = {
  println("Evaluating...")
  1000 * 1000
}
 
println("Before call")
println(expensiveComputation) // Evaluates and prints 1000000
println(expensiveComputation) // Prints cached 1000000 (no evaluating output)

Build Tools & Ecosystem

SBT (Scala Build Tool) Commands

SBT is the standard build tool for Scala projects.

# Compile the project
sbt compile
 
# Run the project
sbt run
 
# Run tests
sbt test
 
# Open interactive Scala REPL with project code loaded
sbt console

Useful Libraries & Frameworks

Apache Spark - Lightning-fast cluster computing framework written in Scala.
Akka & Pekko - Actor model libraries for distributed, resilient, and responsive applications.
Cats & Cats Effect - Pure functional programming library abstractions.
ZIO - Type-safe, composable asynchronous functional effects library.
Circe - JSON serialization/deserialization library using case classes.

Table of Contents

Explorer

Scala

History

Introduction

Advantages

Disadvantages

Remember Points

Basics

Hello World & Entry Point

Comments

Variables and Constants

Primitive Data Types (Any, AnyVal, AnyRef)

Type Inference

Control Flow

If-Else as an Expression

Match Expression (Pattern Matching)

Loops & For-Comprehensions

Breaks & Control Flow Exit

Functions

Method Declaration

Named & Default Parameters

Anonymous Functions & Lambdas

Higher-Order Functions

Currying & Partial Application

Tail Recursion (@tailrec)

OOP — Object-Oriented Programming

Classes & Constructors

Singleton & Companion Objects

Case Classes

OOP — Inheritance & Traits

Class Inheritance

Traits & Mixin Composition

Pattern Matching

Advanced Destructuring

Contextual Abstractions (Scala 3)

Given Instances & Using Clauses

Extension Methods

Generics (Variance & Bounds)

Variance annotations

Type Bounds

Exception Handling

Try / Catch / Finally

Functional Error Abstractions

Concurrency

Futures & Promises

Collections

Immutable Collections

Collections Transformations

File I/O

Reading File contents

Advanced Topics

Lazy Val (Lazy Initialization)

Build Tools & Ecosystem

SBT (Scala Build Tool) Commands

Useful Libraries & Frameworks

More Learn

Explore valuable resources for Scala:

Enjoying the Notes?

Graph View

Backlinks

Recently Updated

Tail Recursion (`@tailrec`)