Getting Started with Scala: Writing Your First Program

Scala is a modern, high-level programming language that combines the best of both worlds—object-oriented programming (OOP) and functional programming (FP). It’s designed to be concise, elegant, and type-safe, making it a great language for everything from small scripts to large-scale systems. Whether you’re coming from a Java background or new to programming, Scala offers a gentle learning curve and powerful capabilities.

In this article, we’ll walk you through an introduction to Scala and show you how to write and run your very first Scala program.

What is Scala?

Scala, short for Scalable Language, is a general-purpose programming language created by Martin Odersky in 2003. It runs on the Java Virtual Machine (JVM), making it compatible with existing Java libraries and frameworks. Here’s why Scala is so exciting:

Concise Syntax: Scala lets you write less code to achieve the same functionality compared to traditional languages like Java.
Object-Oriented and Functional: It seamlessly integrates OOP with functional programming, allowing you to model your problem domain with classes and objects while leveraging the power of functions, immutability, and higher-order functions.
Immutable Data Structures: Scala encourages immutability, meaning data structures can’t be modified after they are created, which can lead to more predictable and bug-free code.
Concurrency: With its built-in support for concurrent programming, such as Actors (via the Akka library) and Futures, Scala is ideal for developing scalable, distributed systems.

Why Learn Scala?

Scala is particularly popular in fields like big data (e.g., Apache Spark is written in Scala), distributed systems, and backend development. Its expressive syntax and functional programming paradigm allow for highly readable, maintainable, and concurrent code, making it a strong contender in modern software development.

Setting Up the Scala Development Environment

Before we can write and run Scala code, we need to set up the development environment. There are several ways to do this, but for simplicity, we’ll use Scala’s command-line REPL and Scala Build Tool (SBT), which is a popular build tool for Scala projects.

Step 1: Install Scala

Scala requires the Java Development Kit (JDK) to run. Follow these steps to install Scala:

Install JDK: If you don’t already have the JDK installed, you can download it from Oracle’s website.
Install Scala: There are a couple of ways to install Scala:
- Using Homebrew (for macOS):
  Run the following command to install Scala and the Scala Build Tool (SBT):

brew install scala sbt

Using SDKMAN (for Linux/macOS/Windows):
SDKMAN is a tool to manage Java-related tools easily. To install SDKMAN, run:

curl -s "https://get.sdkman.io" | bash

Then install Scala:

sdk install scala
sdk install sbt

Verify the Installation: Check that Scala is installed by running:

scala -version

This should print the version number of Scala.

Step 2: Install a Scala IDE (Optional)

While it’s possible to write Scala code using a simple text editor, it’s much easier to develop Scala applications using an IDE with proper syntax highlighting, code completion, and debugging capabilities.

Popular IDEs for Scala include:

IntelliJ IDEA (with the Scala plugin)
Visual Studio Code (with the Metals plugin for Scala)

Now that we’ve set up our environment, let’s dive into writing our first Scala program!

Writing Your First Scala Program: “Hello, World!”

The best way to start learning any language is by writing a simple “Hello, World!” program. Let’s break down the basic structure of a Scala program.

Step 1: Create a New Scala File

You can either run Scala code interactively in the Scala REPL or write it in a .scala file. For this tutorial, we’ll write our code in a file and then run it.

Open a terminal and create a new Scala file:

touch HelloWorld.scala

Now open HelloWorld.scala in your favorite text editor or IDE and write the following code:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }
}

Step 2: Code Explanation

object HelloWorld: In Scala, object defines a singleton object. An object in Scala is similar to a class but it can only have one instance. Here, HelloWorld is the name of our object, and it’s the entry point of our program.
def main(args: Array[String]): Unit: This is the main method, which serves as the entry point for any Scala program. The args parameter is an array of strings that can be used to pass command-line arguments. The return type of the main method is Unit, which is similar to void in Java.
println("Hello, World!"): This prints the string "Hello, World!" to the console.

Step 3: Compile and Run the Program

To run your Scala program, use the following command in the terminal:

scala HelloWorld.scala

This will compile and run the program, printing:

Hello, World!

Congrats! You’ve just written your first Scala program.

Exploring Scala Basics

Now that you have a basic understanding of how to run Scala programs, let’s explore some of the language’s core features.

1. Variables and Data Types

In Scala, you can declare variables using val or var:

val: Used to define an immutable variable (cannot be changed after assignment).
var: Used for mutable variables (can be reassigned).

Here’s an example:

val immutableVar = 10  // Cannot be changed
var mutableVar = 20    // Can be changed

mutableVar = 25  // This is allowed
// immutableVar = 15  // This would cause an error

Scala has the usual data types, such as Int, Double, String, and Boolean.

2. Functions

In Scala, functions are first-class citizens, meaning you can pass them around like any other object. Here’s how you can define and call a function:

def add(a: Int, b: Int): Int = {
  a + b
}

val result = add(5, 3)
println(result)  // Output: 8

Scala also supports anonymous (or lambda) functions:

val multiply = (x: Int, y: Int) => x * y
println(multiply(3, 4))  // Output: 12

3. Control Structures

Scala has familiar control structures like if, for, and while. Here’s an example of an if-else statement:

val age = 18
if (age >= 18) {
  println("You're an adult.")
} else {
  println("You're a minor.")
}

And a for loop example:

for (i <- 1 to 5) {
  println(i)
}

4. Collections

Scala provides powerful collections such as Lists, Sets, and Maps. Here’s how to work with a list:

val numbers = List(1, 2, 3, 4, 5)
val doubled = numbers.map(_ * 2)
println(doubled)  // Output: List(2, 4, 6, 8, 10)

Functional programming techniques like map, filter, and reduce are core to working with collections in Scala.

Moving Forward with Scala

This introductory article gives you a quick overview of Scala and walks you through creating your first program. As you delve deeper into Scala, you’ll encounter powerful functional programming features, advanced type systems, and concurrency models that allow you to build highly scalable applications.

Next steps for learning Scala:

Learn Functional Programming: Explore how Scala supports immutability, higher-order functions, and pure functions.
Work with Collections: Get familiar with Scala’s rich collection library, including advanced operations like fold, reduce, and flatMap.
Build Projects with SBT: Scala Build Tool (SBT) is the go-to for managing dependencies and building Scala applications.

Scala is a versatile language that empowers you to write concise, readable, and efficient code. Whether you’re working with data pipelines, building web services, or diving into functional programming, Scala has something to offer!