John Hunt - A Beginner’s Guide to Scala, Object Orientation and Functional Programming

John Hunt

A Beginners Guide to Scala, Object Orientation and Functional Programming 2nd ed. 2018

This book is dedicated to my wife Denise; you are a constant source of inspiration to me.

This book is intended as an introduction to Scala for computer science students or those actively involved in the software industry. It assumes some familiarity with standard computing concepts, such as the idea of compiling a program and executing this compiled form, and with the basics of procedural language concepts such as variables and allocation of values to variables. However, the early chapters of the book do not assume any familiarity with Object Orientation nor functional programming. They also step through other concepts with which the reader may not be familiar (such as list processing). From this background, it provides a practical introduction to object and functional technology using Scala, one of the newest and most interesting programming languages available.

This book introduces a variety of concepts through practical experience. It also tries to take you beyond the level of the language syntax to the philosophy and practice of Object-Oriented development and functional programming.

In the remainder of this chapter, we will consider what Scala is, why you should be interested in Scala and whether this book is for you.

Scala is a new programming language developed by Martin Odersky and his team at the EPFL (Ecole Polythenique Fererale de Lausanne, Lausanne, Switzerland) and now supported by Lightbend Inc. (previously known as Typesafe).

The name Scala is derived from Sca(lable) La(nguage) and is a multi-paradigm language, incorporating Object-Oriented approaches with functional programming.

What does this mean in practice? It means that you can write applications as pure Object-Oriented solutions using Classes, Objects and Traits. You can exploit inheritance, polymorphism and abstraction and encapsulation techniques. In this respect, Scala is very much like any other Object-Oriented language (such as Java, C# or C++). However, you can also develop solutions using purely functional programming principles in a similar manner to languages such as Haskell or Clojure. In such an approach, programs are written purely in terms of functions that take inputs and generate outputs without any side effects.

Scala though is different in that it is a hybrid programming language. That is, it is possible to combine the best of both worlds when creating a software system. You can therefore exploit Object-Oriented principles to structure your solution but integrate functional aspects when appropriate. Whilst this approach is not unique (the Common Lisp Object Systems did something similar in the 1980s), it is certainly bringing functional programming to the mainstream and integrating it within an environment that can execute almost anywhere.

Of course Scala has not been developed in isolation and has been influenced by many of these and other languages. The influences on the Scala language are shown in Fig..

Fig. 1.1

Scala Genealogy

1.3 Why Scala?

This of course raises the question why Scala and why now? There are a number of reasons why Scala should be a language that is given serious consideration by any development project. We have already mentioned that fact that it coherently brings together two very powerful programming paradigms that combined can allow very elegant, concise and maintainable systems to be created. However, there are other reasons why Scala is of interest. The first is that Scala can be compiled to Java Byte Codes. This means that a Scala system can run on any environment that supports the Java Virtual Machine (or JVM). There are already several languages that compile to Java Byte Codes. This list includes Java but also extends to Ada, JavaScript, Python, Ruby, Tcl and Prolog. Scala is just another such language. However, this has the additional advantage that Scala can also be integrated with any existing Java code base that a project may have. It also allows Scala to exploit the huge library of Java projects available both for free and for commercial use.

Another reason to consider Scala is that one of the design goals for the Scala development team was to create:

A scalable language suitable for the construction of component based software within highly concurrent environments.

This means that it has several features integrated into it that support large software developments. For example, the Actor model of concurrency greatly simplifies the development of concurrent applications. In addition, the syntax reduces the amount of code that must be written by a developer (at least compared with Java). This is because it avoids a lot of the boilerplate code that any Java developer will be familiar with.

To summarise then, the following points can be made that Scala: