(a little bit of) Scala in 6 minutes
Scala is a high-level programming language that has both functional and object-oriented language features. It is designed to be concise, and fast. Scala is compiled to Java bytecode. The executable then runs on a Java Virtual Machine (JVM). Because it is compiled to Java bytecode, Scala has seamless interoperability with Java giving it access to useful Java source code libraries.
Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way.
Scala is a multi-paradigm language that combines both functional and object-oriented features. This allows for programmers who are familiar with object-oriented concepts to make use of object-oriented styles such as classes but also has the benefit of using functional concepts in their programming such as the use of map and filter on collections instead of using loops. This has the advantage of code being more expressive and thus more readable.
Scala is a pure object-oriented in the sense that every value is a type, even functions and numerical values. Since values are class-based, all values are instances of a class.
Any is the supertype of all classes and has several universal methods such as
Any has two subclasses
AnyRef represent reference types. Every user defined types are classified as reference types.
One of the core values of functional programming is that functions should be first-class.
Scala is functional because every function has a value: functions can be passed around as variables (first class functions). What this means is that like standard functions, they can be declared and invoked. But they can also be passed as a parameter to other functions and returned by other functions.
Never Assigned an Identifier
In this example, let’s have a look at the function
map — used to return a new list with the function applied to each element of the original list. The function
x => x * 2 passed into map is anonymous and never assigned an identifier.
Be Passed as a Parameter
The code below shows the function
isAlien passed in as a parameter to
filter demonstrating the functional aspects of Scala.
Be Returned by Another Function
Another feature of functional programming is that functions can return functions. The code below shows a useful use case of this. Sometimes we need to test the logic of a certain function. This can become problematic when functions are dependant on other functions, for example a function that queries a database. It then becomes difficult to test the logic of a single function. If a function is dependant on a function that queries a database, and the unit test for that function fails it becomes difficult to tell if the query to the database failed, or the function logic itself. In scala, we can make use of its function paradigm to isolate dependancies from function logic. Below, the function
fake_dependancy simulates a database query that is always successful, and returns a string. The
method_that_takes_dependancy function takes in a function (the database query) and returns a new function that contains the logic we need to test. Now, since we know the result of the database query is correct, if we test the function we can be sure we are testing the logic only.
Type System Features
Scala can be classified as a statically typed language with type inference. Scala is compiled using the Java Virtual Machine (JVM) or the .NET Common Language Runtime (CLR), and type correctness is checked at compile time. Scala is also strongly typed. This means that in Scala a type
String is only used as a string throughout a program. Only a type
String can be held in the variable’s memory location.
Scala has built in type inference so that programmers often do not have to infer the type of the variables. Before demonstrating type inference, we need to first know the definition of polymorphic methods, and generic classes.
Methods can be parameterized by type, and value. In the code example below,
we define the function
foo to take in a parameter of type
A and a value
x of type A and value y of type
Int . Polymorphic methods specify type variables. This can make code more generic, but keeping the advantages of static typing.
Generic classes are like polymorphic methods. They take in type parameters in square brackets.
When using generic classes and polymorphic methods in scala, scala uses type inference. For example, in the code below the declaration of
second_value is identical. Scala infers from the parameter
5 that its type is
Other Interesting features?
Interoperability with Java
A useful feature of scala is its interoperability with Java source code. This means that Java libraries can be called, and used from a scala program. This seamless integration is a result of the fact that Scala syntax is a superset of Java sytnax. The sample code below shows a program that builds a GUI based off of imported Java libraries.
Another interesting feature in Scala is that it uses lazy evaluation. This means that values are only evaluated when they are needed. This is demoed in the code below. Lazy evaluation can become useful in building an application when a variable is declared, but its value is dependant on another value not available yet. The programmer then needs to make sure that when the lazy val is used, its dependancy is available.
Mutable and Immutable Data
Scala lets programmers define mutable data with the declaration
var , and immutable data with
val . Declaring a variable with
val will not allow the variable to be reassigned. Any attempt at redeclaring immutable data will result in a
reassignment to val error . It is important to note, that although immutable data cannot be reassigned, their values can be changed. The value just cannot be made to point to a different value at a different memory location. The code below shows an example of this. The list
aliens consists of instances of a class
Alien which has a mutable attribute name. The name of the Aliens inside the mutable list can be changed, but we cannot add or remove elements from the list because this would require us to reassign it to a new variable. Having support for mutable types helps keep functions in a Scala program pure, with no side effects.
How does Scala compare with other languages?
Like Haskell, Scala can be used as a purely functional language. However unlike Haskell it is also purely object oriented like Java. Scala shares similar features with many languages because of both of its functional and object-oriented paradigm, but is most similar to Java because it runs in the Java Virtual Machine environment.
According to Google’s benchmark report, the advantage that Scala holds over Java, is its conciseness, and code complexity optimizations due do it incorporating both functional and object-oriented features into one language. However, Scala does have its disadvantages in that it is a complex language and thus has a high learning curve for new programmers. Also, many developers argue that conciseness often comes at the cost of readability. An example is the function declaration below. One can argue, that although the code is concise, it lacks expressiveness.
Resources that helped me write this piece
Scala combines object-oriented and functional programming in one concise, high-level language. Scala's static types…www.scala-lang.org
In this experience report we encode a well speciﬁed, compact benchmark in four programming languages, namely C++, Java…ai.google
Scala is in a complex fight to overthrow Java. Java has remained one of the most popular, versatile programming…dzone.com
Thanks for contributing an answer to Stack Overflow! Some of your past answers have not been well-received, and you're…stackoverflow.com
Scala has a built-in type inference mechanism which allows the programmer to omit certain type annotations. It is, for…docs.scala-lang.org
This lesson shows how to write Scala functions that take other functions as input parameters.alvinalexander.com
This tutorial from the Scala Cookbook shows how to test for the existence of a key or value in a Scala Map by using…alvinalexander.com