Scala is a contraction of the words “scalable” and “language.” The scalability of a language is different from the scalability of a program or application. The scalability of a program is defined in terms of its performance, while the scalability of a language has a broad ranging definition, in that the high scalability of Scala is a consequence of the fusion of object-oriented and functional programming. Scala’s functional programming constructs let you compose complex functions from simple functions. Scala’s object-oriented constructs let you structure highly adaptable objects through innovations in object-oriented constructs of Java. While Java has undoubtedly ushered in a wave of new era in software development, this initial chapter discusses why Scala supplants Java as a worthy successor and gets you started on a wonderful journey of great distances.

Why Scala?

Scala is a language that addresses the major needs of many Java developers. It is a statically typed, mixed-paradigm, JVM language with a terse and flexible syntax, a superior type system bestowing the developer with the ability to be more efficient with less code and minimum ceremony. Now let’s explore some idioms that make Scala such a promising and a state-of-art language.

A Concise Language

Scala is a programming language designed to make your program, well, concise. Let’s take a quick look at how your code can be concise using Scala. Listing 1-1 shows a simple Java class that you would write to encapsulate a book object.

Listing 1-1. A Book Class in Java

class Book{
private String title;
private int numberOfPages;

public Book(String title, int numberOfPages) {
this.title = title;
this.numberOfPages = numberOfPages;
}
}

There is nothing special about Listing 1-1. It is a simple Book class that encapsulates the title of the book and number of pages in what amounts to eight lines, not to mention loads of parentheses, braces, and semicolons floating around. Now compare Listing 1-1 with Listing 1-2, which is the same Book class written using Scala.

Listing 1-2. A Book Class in Scala

class Book(title: String, numberOfPages: Int)

You don’t have to be a Scala expert to appreciate how succinct and terse Listing 1-2 is compared to Listing 1-1, although if you have a keen eye, you would immediately notice in Listing 1-2, omitted extraneous semicolons, to say the least.

Lightweight Syntax

Scala does not include the useless, even troublesome, features of Java such as static members, primitive types, break and continue statements, enums, or wildcards just to name a few. Scala has a lightweight syntax that is a result of two design decisions:

• Not taking a “one size fits all” philosophy but aiming at allowing the users to structure their programs to suit their needs
• Including features such as type inference and extensible APIs

We will explain type inference in the subsequent sections; meanwhile here is an example of Case classes, so you can appreciate the lightweight syntax of Scala. Case classes are the Scala equivalent of Java POJOs and will be explained in Chapter 3. The essence of Case classes is that they don’t have all the boilerplate code that goes with Java POJOs such as getter and setter methods, equals and hashCode methods, toString method to name a few. There are several other handy methods that are also generated from Case classes. These and several other features will be explained in this book in detail; meanwhile, just to get a feel of light-weightiness of Scala syntax, breeze through the code that we present in this section starting with Listing 1-3.

Listing 1-3. Lightweight Book POJOin Scala

case class Book(var title: String, var numberOfPages: Int)

Even though we have not shown you how to install Scala and execute Scala programs, we’ll compile Listing 1-3 for you so that we can show you its equivalent in Java. We’ve put the code in Listing 1-3 in a file named Book.scala.

Then we compile the file using this command:

>scalac Book.scala

This creates two class files, Book.class and Book$.class.

We then disassemble Book.class with this command:

> javap Book

Listing 1-4 illustrates the Java equivalent for Listing 1-3 generated by javap command. This is how your Java Book class would have looked if you had written code for all the features power-packed in a single line of Scala code in Listing 1-3.

Listing 1-4. Java Equivalent of Book POJO in Listing 1-3

public class Book implements scala.Product,scala.Serializable {
  public static scala.Option<scala.Tuple2<java.lang.String, java.lang.Object>>unapply(Book);
  public static Book apply(java.lang.String, int);
  public static scala.Function1<scala.Tuple2<java.lang.String, java.lang.Object>, Book> tupled();
  public static scala.Function1<java.lang.String, scala.Function1<java.lang.Object, Book>>curried();
  public java.lang.String title();
  public void title_$eq(java.lang.String);
  public int numberOfPages();
  public void numberOfPages_$eq(int);
  public Book copy(java.lang.String, int);
  public java.lang.String copy$default$1();
  public int copy$default$2();
  public java.lang.String productPrefix();
  public int productArity();
  public java.lang.Object productElement(int);
  public scala.collection.Iterator<java.lang.Object> productIterator();
  public boolean canEqual(java.lang.Object);
  public int hashCode();
  public java.lang.String toString();
  public boolean equals(java.lang.Object);
  public Book(java.lang.String, int);
}

Consider Listing 1-4 and then count how many lines of code the Java equivalent Book class has.

Multiparadigm Language

Scala is a programming language that provides a best-of-two-worlds experience for developers. Dynamic-language users will find Scala’s concise syntax and type inferencing a way to reduce the boilerplate needed when writing programs in Java. Functional programmers will find Scala’s powerful type system a great way to reason about code. Scala also has many functional programming facilities, including features found in pure functional languages such as Haskell.¹

Object-Oriented Language

Scala is a pure object-oriented language that does not include primitive types and in that sense everything is an object. Thus, an operation between two objects is viewed as an invocation of a method on the first operand to send a message to the second operand. Because numbers are objects in Scala, they also have methods. And in fact, an arithmetic expression such as the following:

1 + 2 * 3 / x

is equivalent to the following expression:

(1).+(((2).*(3))./(x))

Scala supports not only pure object-oriented programming, unlike Java, but Scala also improves upon Java’s support for OOP with the addition of traits. Scala traits are akin to Java interfaces with an important difference. The Java interface defines a set of methods that must be implemented on all classes that implement the interface. Scala traits can do everything that Java interfaces can do, but they can also include method implementations. This comes in very handy because you don’t have to create complex class hierarchies to avoid duplicating code. Other than traits, Scala does not support static members like Java does, because static members are not associated with an actual instance. Instead a Scala class can provide a singleton object. A singleton object is declared using the object keyword, as shown in Listing 1-5.

Listing 1-5. Singleton Object in Scala

object HelloWorld {
    def greet() {
        println("Hello World!")
    }
}

Listing 1-5 defines a singleton object called HelloWorld. You can call the method greet in the following manner:

HelloWorld.greet()

This is like calling a static method in Java, except you are calling the method on a singleton object instead. We look at singleton objects in greater detail in Chapter 3.

Functional Language

Scala is a functional language, which means that you can pass functions to methods and functions, and return them from methods and functions, as well as assign them to variables. A function is a block of code that takes parameters and returns a value. As we mentioned earlier, everything is an object in Scala, so functions too must be objects. We will illustrate this through an example. Listing 1-6 defines a function that returns square of a number.

Listing 1-6. A Simple square Function

(i: Int) => { i * i }

With a little bit of imagination or if you have a mathematical bent it is not very difficult to understand Listing 1-6. It defines a function that takes an Int parameter and returns a value that is square of the provided Int.

Now we will show you functions are objects, in this case we intend to show that the square function defined in Listing 1-6 is an object in Scala. You can assign the function to a variable as shown in Listing 1-7 as you would assign any object to a variable and you can pass the function as an argument to a method, just as you would pass any other object as an argument to a method.

Listing 1-7. Assigning the Function to a Variable

val square = (i: Int) => { i * i }

The variable square in Listing 1-7 is an instance of a function. You can now invoke square just as you would call a method as shown in Listing 1-8.

Listing 1-8. Invoking the square Function

square(3)

We’ve just scratched the surface of functional programming. Functional programming is one of the aspects that makes Scala difficult to learn or atleast it makes it appear difficult. We will explain functional programming in detail in Chapter 4.

Interoperability and Seamless Integration with Java

Scala can be used in tandem with Java programs. Scala can call any Java code, subclass any Java class, and implement any Java interface. Java code can call into Scala code if the Scala code subclasses a Java class or implements a Java interface. Scala code, under the hood, reuses Java libraries and Java types. Scala allows you to add value to existing Java code because Scala was designed for seamless interoperability with Java and because ultimately Scala programs compile to JVM bytecode.

There are features of Scala, however, that cannot be accessed from Java, including traits with defined methods, classes and methods that have names, which are illegal in Java, and Scala’s advanced types. We will show how to access these from Java in Chapter 10.

Language for the Java Virtual Machine

The JVM is the runtime environment that provides you with the ability to use different programming languages. With the latest version, Java 8, Java is no longer a privileged JVM language and is now simply one of the many languages that run on the JVM (for a long time it’s been common to run other languages on the JVM, it’s just that Java is now no longer privileged). The JVM languages can be largely classified into two types:

• Languages designed for the JVM, such as Clojure, Groovy, Java, and Scala.
• Existing languages ported to theJVM, such as JRuby, Jython, and Rhino.

Scala source code is intended to be compiled to Java bytecode, so that the resulting executable code runs on a Java virtual machine. Java libraries may be used directly in Scala code and vice versa.

We introduced a few idioms that make Scala so powerful. However, there are many other features that we did not mention. We will discuss them in detail throughout this book. Next we will start writing some Scala. To that end, you need to install Scala first.

Installing Scala

As a JVM language, Scala requires the use of a Java runtime. Scala 2.11, the latest version as of writing this book, needs at least Java 6, but we recommend installing at least Java 7 for improved performance. You can download the latest JDK from Oracle, which is available for most platforms. Once installed, verify you have at least Java 6 by running java -version from the command line as shown:

>java -version

Once Java is installed, download the Scala 2.11 distribution from http://www.scala-lang.org/download/. Installing Scala is relatively simple and should only take a few minutes. On UNIX systems (including Mac OS X), download the software from the Scala download page to a directory on your computer such as $HOME/scala, and then add these lines to your $HOME/.bash_profile file:

export SCALA_HOME=/Users/Al/scala
PATH=$PATH:/Users/Al/scala/bin

Once you’ve done this you should have access to the scala and scalac commands at your command line. You can follow a similar process if you’re using Microsoft Windows, or you can use an MSI installer from the download page at the link provided earlier. Once installed run the scala command from the command line as shown:

>scala

scala>

When you see the Welcome to Scala version 2.11.1 message and the scala> prompt you are in the Scala interpreter, also called REPL(read-eval-print loop), and you are ready to start coding. In the section that follows, you will learn what REPL is and how to use it.

Scala at the Command Line and Scala Scripts

Scala offers different ways to run programs:

• Interactively at a REPL command line.
• Single-file Scala scripts.
• Compile your Scala programs into class files that can be combined into JAR files, as in Java.

We will now look at each of these ways to run programs.

Interactive Scala

You’ll find the Scala REPL familiar if you have already used other REPL shells such as those in Python, Ruby, or Groovy. The REPL is an excellent tool to learn the Scala language quickly. Let’s get started using the REPL by implementing the ubiquitous “Hello World” application. To start Scala’s REPL, open a command prompt and type scala. You should see the following:

>scala

Using the interactive interpreter you can run your first Hello World by using the println method:

scala> println("Hello World!");

You can enter single lines of code and multiline code on REPL to evaluate and compile. First we will look at how to use single lines of code on REPL, later we will see how to enter multiline code on REPL.

You can start typing as shown here and see how the single-line code is evaluated in Scala:

scala> 1 + 1

The output is a result variable res0 and the type of the value Int. As you can see, Scala interpreter infers the value type as Int for you. Any variables you created are available for the lifetime of your session, that is, you can use res0 from the previous output like so:

scala> res0 * 8

Now you can go on to use res1 and so on.

You saw that Scala interpreter infers the value type for you. Let’s now create a String variable:

scala> val x = "Hello World"

As you can see Scala interpreter infers the String type for you. Now test the interpreter a little bit. We will use the result variable from the previous output, x, which is a String type such that it returns an Int:

scala> var xl = x.length

As you can see Scala interpreter returns an Int value.

Now we will access Java library:

scala> import java.util._

Now that we have java.util library in session we can use it, like so:

scala> val d = new Date

A help system is available and can be started by entering the :help command. You can see there are several commands available. For example, until now we have been entering single-line code on REPL. A multiline paste mode supports entering multiple lines of code to be compiled together, and external source code and libraries can be loaded at any time.

Enter the :paste command on REPL. You see this output:

scala> :paste

Now enter multiline code as shown:

scala> :paste

val v = 5
if (v==5)
print("true ")
else
print("false ")

scala>

To quit the interpreter, type :quit or :q

scala> :quit

Scala Scripts

Another way to execute Scala code is to type it into a text file and save it with an extension .scala. You can then execute that code by typing filename.scala. Open up your favorite text editor: Emacs, vi, TextMate, whatever. Create a new file called HelloWorld.scala and place the following line in it:

println("Hello World!")

Save the file. In Scala, it’s short, simple, and to the point.

Open a terminal window or command prompt, change to the directory where the file is, and type:

scala HelloWorld.scala

You should see:

In Scala, you can write simple programs that look and feel like scripts that you would write in Ruby or Python. In this case, you’re calling the println method with the string constant Hello World! It’s a thin layer on top of System.out.println(). This is like the java.lang package that is automatically imported in every Java program.

Scala scripts do not have an explicit main method. In fact, when you run your script, Scala wraps the entire file into the main method of a class, compiles the code, and calls the generated main method. All you have to do is put valid Scala code in a file.

You can access the command-line arguments in your script with the argv variable, which is an Array[String].

Compiling Scala Programs

You have already seen how to compile Scala programs using the scalac command line tool. You can compile Scala programs just as you compile Java programs, and the results are JVM class files that can be packaged into JAR files. The Scala compiler requires that source files contain one or more class, trait, or object definitions. To compile Scala source files into class files, type the following:

> scalac File1.scala File2.scala

However, startup time for the compiler is non-trivial. You can also compile using the fast Scala compiler, fsc available as REPL command. You can see this when you type :help on REPL:

> fsc File1.scala File2.scala

fsc is a separate compiler process that continues to run, waiting for new compilation jobs, even after the compilation process is finished. This results in much faster compilation times, but if you’re on a machine with limited RAM, you might not want to keep the compilation process alive.

If you are working on medium-sized to large projects, you probably use some sort of build tool such as Ant or Maven. There are Scala plug-ins for both Ant² and Maven,³ so you can integrate Scala code into existing Java projects with very little effort and no requirement of using new build tools. Finally, similar to Maven or Ant, SBT⁴ is an open source build tool for Scala and Java projects, which provides native support for compiling Scala code and integrating with many Scala test frameworks and dependency management, continuous compilation, testing, and deployment.

Your First Scala Programs

In this section, we’re going to write a couple of basic Scala programs. These programs will give you a sense of Scala’s flavor and get you acquainted with running Scala programs.

Hello World

Yep, it’s the ubiquitous “Hello World” program again. But this time you will execute the Hello world program in the context of an application. As you know, you can execute Scala code by first compiling it using the scalac command line tool. Then the code will need to be executed in the context of an application so you will need to add an object with a main method (see Listing 1-9).

Listing 1-9. HelloWorld

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

You learned earlier that Scala does not support static members like Java does, because static members are not associated with an actual instance. We showed you that instead of static members, Scala provides an object construct with which you can declare a singleton object. You will learn more about singleton objects in Chapter 3.

In Listing 1-9, the main method is defined in an object, not in a class. Scala program processing starts from the main method, which is a mandatory part of every Scala program. The main method is not marked as static. The main method is an instance method on a singleton object that is automatically instantiated. There is no return type. Actually there is Unit, which is similar to void, but it is inferred by the compiler.

You can explicitly specify the return type by putting a colon and the type after the parameters:

def main(args: Array[String]) : Unit = {
                       }

Scala uses the def keyword to tell the compiler that this is a method. There is no access level modifier in Scala. You have public modifier in Java in this context. Scala does not specify the public modifier because the default access level is public.

Printing Some Numbers

Let’s write a program that will print the numbers from 1 to 10 in the Print1.scala file:

for {i <- 1 to10}
println(i)

You can run the code by typing scala Print1.scala in the terminal. The program assigns the numbers 1 to 10 to the variable and then executes println(i), which prints the numbers 1 to 10. for means much more in Scala than in Java. You can nest expressions in a for comprehension (the fancy Scala name for the for statement). In the Print2.scalafile, put

for {i <- 1 to10
j <- 1 to10}
println(i* j)

In this program, we are iterating over 1 to 10 in an outer loop and assigning each number to i. In the inner loop, we are also iterating from 1 to 10 and assigning each number to j. The product of i * j is printed, so you’ll see 10 lines output. There are many more uses of the for comprehension that we’ll cover later in the book.

Summary

In this chapter, you got a glimpse of what Scala is, and why it should be learned. You looked at how to build and run Scala programs. You saw how Scala interpreter (REPL) provides a learning environment. We walked through some Scala programs that demonstrated various aspects of Scala. In the next chapter, we’ll dive deeper in the basics of Scala.

___________________________

¹http://www.haskell.org/haskellwiki/Haskell

²http://ant.apache.org/

³http://maven.apache.org/

⁴http://www.scala-sbt.org/