In this lesson, you’ll discover why Scala is an excellent language to learn and why its adoption is increasing so rapidly. You’ll see how Scala relates to the JVM and the key features that make it unique. You’ll also start looking at snippets of Scala code to get an idea of its appearance. After giving you an overview of the Scala language, you’ll continue with the next lesson, in which you’ll install the Scala REPL and use it to interpret snippets of code.
highlight, annotate, and bookmark
You can automatically highlight by performing the text selection while keeping the alt/ key pressed.
Why should you spend time and effort in learning Scala? Why is it becoming so popular? What are the advantages of adopting it? Let’s discuss its main selling points.
The JVM
The JVM is the standard platform for running Scala programs. Sun Microsystems introduced it in 1994—more than 25 years ago. Since then, the industry has been extensively relying on it. The Java community has also been extremely active, and it has produced an impressive amount of libraries. Thanks to its integration with Java, you can use all these libraries in your Scala programs; this is also true for any Java legacy code you or your company may have.
A Hybrid Language
Scala manages to combine two programming techniques that are considerably different: the object-oriented style with the functional one. When executing code on the JVM, the object-oriented approach can be more performant but prone to errors. When using mutable state, your program will re-allocate its memory: every time a change occurs, it will change the data in place. However, sharing state can cause your application to suffer from data inconsistency issues due to multiple processes accessing and modifying the same portion of data.
A functional approach can be more readable and reusable but not as performant. Thanks to immutable data and structures, you can guarantee your program’s correctness when dealing with concurrency: your data never changes, so it is safe to share it. Your code will also be easier to understand and reuse because all its components will be independent of external factors outside its control. But recreating data rather than updating could be a memory-expensive operation, even though it has massively improved thanks to numerous optimizations and efficient garbage collection strategies in recent years.
Figure 1.1 Comparison of the object-oriented and functional programming styles and how they handle different programming tasks
Concise Syntax
Scala’s programming style is relatively concise, particularly when compared to other languages like Java. Having a compact syntax can increase both the productivity and readability of your program. At the beginning of your journey with Scala, you may find it quite overwhelming. In this book, syntax diagrams will help you master new topics and make your learning path smoother.
Flexibility
Scala is extremely flexible: you can achieve the same goal in more than one way, making the language extremely fun and exciting to use. The opportunity to choose between different programming paradigms allows you to gradually shift your mindset from one approach to another without committing to a specific style since day one. For example, you can dip your toe in the functional programming world without any long-term commitment. In this book, you’ll start writing Scala code using an object-oriented style and then gradually move to a more functional one.
Concurrency
Big Data and Spark
Thanks to Scala’s features and optimizations at its compile level, the community has developed new performant tools for big data processing. Apache Spark is the most popular of these tools. Thanks to Scala’s lazy evaluation, which is a topic you are going to discover in unit 8, Spark can perform optimizations at compile time that have huge impacts on its runtime performance:
Source: https://spark.apache.org
discuss
Scala takes its name from the word scalable. Martin Odersky and his team designed it in 2004 with the intent of creating a language for the Java Virtual Machine (JVM) that can easily handle high volumes of requests.
To understand the execution of a Scala program, let’s compare it with the typical execution flow of a Java program; figure 1.2 provides a visual representation of the two processes. The JVM is a machine to perform tasks by executing a well-defined set of operations, called bytecode. A JVM language aims to translate its code into executable JVM bytecode, usually formed by multiple files with extension *.class. When coding in Java, you save your source files with extension *.java and use the compiler javac to produce a jar file containing the generated bytecode. When writing Scala code, your source files have extension *.scala. The Scala compiler called scalac is in charge of translating the code into bytecode. You can seamlessly add Java sources and depend on Java libraries in your Scala codebase. The Scala compiler fully integrates with the bytecode that the Java compiler produces, making the integration between the two languages straightforward.
Figure 1.2 Comparison between the execution of a Java program with a Scala one. The Java source code has extension *.java, and javac translates it into bytecode files with extension *.class. You save Scala code in files with extension *.scala, and scalac is the compiler responsible for converting them into bytecode. The JVM is now ready to run the bytecode, usually conveniently grouped in a *.jar file.
settings
Since 2004, Scala has evolved a lot, but its fundamental features have not changed. In this section, you’ll glance at a few fragments of Scala code, and you’ll learn about each of these topics in this book.
Scala is Object-Oriented
Listing 1.1 MyClass example
// our first Scala example #1
class MyClass(name: String) { #2
def sayHello(otherName: String) =
s"Hi $otherName, my name is $name!" #3
}
In unit 1, you’ll learn how to define classes and subclasses. In unit 4, you’ll also discover case classes to present data in an immutable manner.
Singleton instances are instances that you should initialize at most once. Scala offers a dedicated syntax for them: you usually refer to them as objects. Do not be confused by the term object, as it can refer to an instance rather than a singleton in other languages. In unit 2, you’ll learn about singleton objects in Scala and how not to be confused by the terminology.
Listing 1.2 MySingleton example
object MyObject { #1
val a = new MyClass("Scala") #2
println(a.sayHello("Martin"))
}
Exceptions are another typical feature of an object-oriented language. They represent code anomalies: you can throw and catch them to control your program’s execution flow. In Scala, exceptions are similar to those in languages such as Java, Python, and C++.
Listing 1.3 Example of throwing and catching exceptions
try {
throw new IllegalStateException("ERROR!") #1
} catch {
case ex: RuntimeException => #2
println("Something went bad...")
}
You’ll learn about try-catch expressions in detail in unit 3, in which you are also going to discover partial functions. In unit 6, you’ll master how to handle errors without throwing exceptions using a more functional and safe approach that uses types.
Mutable data structures and assignments are also part of the language. The language’s design discourages their use, but you can still take advantage of them when needed. In lesson 4, you’ll learn about the difference between a value and a variable. In units 5 and 6, you’ll also discover what the Scala Collections have to offer.
Scala is Functional
FP languages base their entire structure on functions. Functions play a big part in Scala as its first-class citizens. In lesson 6, you’ll learn their basics and how to define them. In unit 4, you’ll discover functional purity and its several advantages and how you can use functions as parameters or return values: you refer to them as higher order functions. They allow you to create powerful abstractions that simplify and remove code duplication in a way that is usually not so easily achievable in an object-oriented approach.
Listing 1.5 Example of Higher Order Function
def divideByTwo(n: Int): Int = n / 2 #1 def addOne(f: Int => Int): Int => Int = #2 f andThen(_ + 1) def divideByTwoAndAddOne = addOne(divideByTwo) #3
Scala has a Robust Type System
Scala is a statically typed language. Types define the acceptable range of values for your computation. Thanks to them, the compiler can check at compile time that your code doesn’t violate any constraints, which makes your code more reliable and less prone to errors at runtime. Scala has a type inference system, so you do not have to specify the intended type for every expression of your program, making your code less verbose. Languages that do not have a type inference system require you to provide types explicitly and tend to be more verbose. Scala’s type system is also quite flexible: you can reuse existing or create custom types to ensure business requirements at the type level. Starting from unit 4, you’ll discover the most common types the language has to offer. In unit 7, you’ll see how to use type classes and define custom types to enforce requirements at compile time.
Scala’s Integration with Java
Listing 1.6 Java to Scala code example
// file Snippet.java
String dateAsString = "22.11.2017";
SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yyyy" );
Date date = format.parse(dateAsString);
// file Snippet.scala
import java.text.SimpleDateFormat
import java.util.Date
val dateAsString = "22.11.2017"
val format = new SimpleDateFormat("dd.MM.yyyy")
val date: Date = format.parse(dateAsString)