# Scala Explained: Objects and Functions on the JVM

## Introduction

Java gave the world a massive ecosystem and a verbose language; functional languages gave elegance and a smaller ecosystem. Scala, released in 2004, refused to choose: it runs on the Java Virtual Machine, uses every Java library, and blends object-oriented and functional programming in one language. It powers Twitter's backend, Apache Spark, and much of big data — and its lesson is that the two styles are not enemies, but tools for different parts of the same program.

## Case classes, pattern matching, and immutability

Scala's model blends the familiar with the functional:

- Everything is an object — like Java, but with type inference, so you write less boilerplate for the same safety.
- Case classes — concise data holders with built-in equality and pattern matching, the natural way to model messages, events, and records.
- Pattern matching — destructure data and branch on its shape in one readable expression, replacing chains of if and `instanceof`.
- Immutability by default — prefer `val` over `var` and immutable collections, so concurrent code has fewer surprises; mutability is available, just not the default.

A tiny example shows the blend — a `case class`, a function, and pattern matching:

```
case class User(name: String, age: Int)
def describe(user: User): String = user match {
  case User(name, age) if age >= 18 => s"$name is an adult"
  case User(name, _)                => s"$name is a minor"
}
println(describe(User("Ayesha", 25)))
// Ayesha is an adult
```

Objects hold the data, functions transform it, and the compiler checks both — that blend is Scala's identity.

## The honest trade

Scala's trade is complexity and hiring: it is a big language with many ways to do the same thing, compile times can be slow, and the talent pool is smaller than Java's or Kotlin's. The rule of thumb: Scala when you need JVM ecosystem plus functional power, especially for data pipelines; Kotlin when you want a simpler modern JVM language; Java when team familiarity dominates.

## Takeaway

Scala is objects and functions on the JVM: `case class`es, pattern matching, and immutability by default, with every Java library available. It trades simplicity for expressive power — and for data-intensive systems, that power is why it endures.

Originally published at https://practicaldevblog.blogspot.com/2026/10/scala-explained-objects-and-functions.html