Before reading this post, please go through my previous two posts at “Scala Basic” and “Scala Intermediate” Interview Questions and Answers to get some basic knowledge about Scala Language.
In this post, we are going discuss about some Advanced Scala Interview Questions that are related to Scala Advanced concepts and also some Real-time project related concepts. Note: As this list has already become very large, I’m going to deliver another post with remaining Questions and Answers. Please refer that post at: “Scala Intermediate and Advanced Interview Questions and Answers” We will also discuss Scala/Java Concurrency and Parallelism Interview Questions and Answers, which are useful for Senior or Experienced Scala/Java Developer.
In this section, we are going to list out all Scala Intermediate Interview Questions and in next section we will discuss them in detail.
In this section, we will pickup each and every question from above list and discuss in-detail with suitable examples(if required). If you want to understand these concepts in-depth with examples, please go through my previous posts in Scala Tutorials section.
Current Scala’s stable is 2.11.7. It supports Java SE 7. The major change or update in Scala 2.12 version is that it supports Java SE 8 or later versions only. Scala 2.12 is not a binary compatible with the 2.11.x series. It’s still in Mile Stone Builds only.
In Scala, Option is used to represent optional values that is either exist or not exist. Option is an abstract class. Option has two subclasses: Some and None. All three (Option, Some and None) are defined in “scala” package like “scala.Option”. Option is a bounded collection in Scala, which contains either zero or one element. If Option contains zero elements that is None. If Option contains one element, that is Some. Some is used to represent existing value. None is used to represent non-existent value. Example:-
def get(val index: Int): Option[String]
Let us assume that this method is from List. This method has a return type of Option[String]. If List contains elements, this get method returns “Some[String]” element available in that index position. Otherwise, it returns “None” (that is no elements) Some is a case class and None is an Object. As both are case class/object, we can use them in Pattern Matching very well. The combination of all these three definitions is known as Option/Some/None Design Pattern in Scala.
In Scala, Either is an abstract class. It is used to represent one value of two possible types. It takes two type parameters: Either[A,B]. It exactly have two subtypes: Left and Right. If Either[A,B] represents an instance A that means it is Left. If it represents an instance B that means it is Right. This is known as Either/Left/Right Design Pattern in Scala.
Scala’s Option is similar to Java SE 8’s Optional. Java SE 8 has introduced a new utility class Optional to represent existing or non-existing of some value. Optional is available in java.util package. Both Scala’s Option and Java SE 8’s Optional are used to represent optional values. Both are used to avoid unwanted null checks and NullPointerException.
The following are the Advantages of Functional Programming (FP) or Advantages of Pure Functions:
There are many Scala-Based Framework to develop RESTful Web Services. Most popular frameworks are:
Swagger is is the best tool for this purpose. It is very simple and open-source tool for generating REST APIs documentation with JSON for Scala-based applications.
Like JPA, Hibernate and Toplink etc ORM Frameworks for Java-based applications, There are many ORM frameworks to use in Play/Scala based applications. Popular ORM frameworks for Play/Scala based applications:
ReactiveMongo is the best Scala Driver to develop Play/Scala applications to persist data in MongoDB NoSQL data store. It supports fully non-blocking and asynchronous I/O operations.
Thousands of clients are using Play and Scala in Production. The following list is the more popular clients who are using Play and Scala actively.
Play 2 is completely written in Scala. If we use Java with Play framework, we need to face many issues because Java does not support full FP features. Scala is the best option to use with Play framework to develop Highly Scalable, Better Performance with Concurrency/Parallelism and Low latency applications, because:
As Scala supports Multi-Paradigm Programming(Both OOP and FP) and uses Actor Concurrency Model, we can develop very highly Scalable and high-performance applications very easily.
The following three are most popular available Build Tools to develop Play and Scala Applications:
SBT stands for Scala Build Tool. Its a Simple Build Tool to develop Scala-based applications. Most of the people uses SBT Build tool for Play and Scala Applications. For example, IntelliJ IDEA Scala Plugin by default uses SBT as Build tool for this purpose.
The following are most popular available Unit Testing, Functional Testing and/or BDD Frameworks for Play/Scala Based applications:
SCoverage is the Code-coverage tool for Play and Scala based applications. SCoverage stands for Scala Code-coverage tool. It has three separate plug-ins to supports the following build tools:
Like Checkstyle for Java-Based Applications, Scalastyle is best Scala style checker tool available for Play and Scala based applications. Scalastyle observes our Scala source code and indicates potential problems with it. It has three separate plug-ins to supports the following build tools:
It has two separate plug-ins to supports the following two IDEs:
The following two popular IDEs support Play and Scala-Based Applications Development:
They support by using Scala Plugins like Eclipse IDE has a Scala IDE for Eclipse to support Play and Scala-Based Applications Development. IntelliJ IDEA has a plug-in like “Scala Plugin for IntelliJ IDEA” to support “Scala, SBT and Play 2 Framework” based applications.- What is the default Unit and Functional Testing Framework for Play? What is the default Build Tool for Play? What is the Default Template Engine for Play? What is the built-in Web Server available in Play Framework? Play Framework’s default Unit and Functional Testing Framework is Spec2. It is very easy to test Play/Scala based applications using Spec2 Framework. Play Framework’s Default built-in template is “Twirl”. It was developed in Scala. By using these templates, we can develop Play/Scala based applications very easily. The Built-in or Default Web Server available for Play Framework is Netty Server.
Because Scala supports the following extra features, it is better than Java 8:
Anonymous Function is also a Function but it does not have any function name. It is also known as a Function Literal. The advantages of a Anonymous Function/Function Literal in Scala:
Higher Order Function (HOF) is also a function but which performs one, two or both of the following things:
Case class is also a class, however when we compare it with normal class, it gives the following extra features or benefits:
All these features are added by Scala Compiler at compile-time. It is not possible with normal class.
The following are the major advantages of Play/Scala stack to develop web applications:
Java’s OOP constructs, which are not supported by Scala:
Scala’s OOP constructs, which are not supported by Java: OR The new OOPs constructs introduced by Scala, but not supported by Java:
Call-by-name means evaluates method/function parameters only when we need them or we access them. If we don’t use them, then it does not evaluate them. Scala supports both call-by-value and call-by-name function parameters. However, Java supports only call-by-value, but not call-by-name. Difference between call-by-value and call-by-name: The major difference between these two are described below:
def myFunction(a: Int, b: Int) { }
Here both a and b are Call-by-value parameters to myFunction. Call-by-name:
def myFunction(a: Int, b: => Int) { }
Here both a is a Call-by-value parameter and b is Call-by-name to myFunction.
The following are the most popular MVC frameworks available for Scala Language to develop Web Applications:
Most of the Java-based projects uses Maven as their Build tool. However, most of the people uses SBT as build tool to develop their Scala-based applications, but Some Teams uses Maven too as a build tool to develop their Scala-based applications. Maven folder structure for both Java-based and Scala-based projects is almost same just one folder name change as shown in the below diagrams: java and scala folder names. Java-based Maven Project Folder Structure: Scala-based Maven Project Folder Structure:
Not only in Java and Scala, in almost all OOP languages Constructor is used to create (or assemble) an object or an instance of a Class using it’s parameters (or components). Extractor is quite opposite to Constructor. In Scala, Extractor is used to decompose or disassemble an object into it’s parameters (or components). In Scala, apply method is a Constructor. Internally, Extractor uses unapply method to decompose an objects into it’s parts (or parameters). In Scala, Extractor is mainly used in Pattern Matching concept. We will discuss Pattern Matching concept soon.
This ‘???’ three question marks is not an operator, a method in Scala. It is used to mark a method which is ‘In Progress’ that means Developer should provide implementation for that one. This method is define in scala.PreDef class as shown below:
def ??? : Nothing = throw new NotImplementedError
If we run that method without providing implementation, then it throws ‘NotImplementedError’ error as shown below:
scala> def add(a:Int, b:Int) : Int = ???
add: (a: Int, b: Int)Int
scala> add(10,20)
scala.NotImplementedError: an implementation is missing
In Scala, both List and Stream are from Collection API and works almost similar. Both are Immutable collections. However, there is one main difference between List and Stream in Scala Collection API: That is List elements are evaluated Eagerly and Stream elements are evaluated Lazily that means when we access them.
scala> var list1 = List(1,2,3,4)
list1: List[Int] = List(1, 2, 3, 4)
Here we can observe that all List elements evaluated at the time of creating List object. However, if we do same thing on Stream, we cannot see all elements. We can see only first evaluated element and remaining elements are evaluated lazily as shown below:
scala> var s1 = Stream(1,2,3,4)
s1: scala.collection.immutable.Stream[Int] = Stream(1, ?)
When we want Lazy collection to evaluate elements only when we access them then it’s better to use Stream.
In Scala Collection API,
scala> var list1 = List(1,2,3,4)
list1: List[Int] = List(1, 2, 3, 4)
scala> list1 = 0 :: list1
list1: List[Int] = List(0, 1, 2, 3, 4)
scala> var list1 = List(3,4,5)
list1: List[Int] = List(3, 4, 5)
scala> val list2 = List(1,2) ::: list1
list2: List[Int] = List(1, 2, 0, 1, 2, 3, 4)
scala> var s1 = Stream(1,2,3,4)
s1: scala.collection.immutable.Stream[Int] = Stream(1, ?)
scala> s1 = 0 #:: s1
s1: scala.collection.immutable.Stream[Int] = Stream(0, ?)
scala> var s1 = Stream(1,2,3,4)
s1: scala.collection.immutable.Stream[Int] = Stream(1, ?)
scala> val s2 = Stream(-1,0) #::: s1
s2: scala.collection.immutable.Stream[Int] = Stream(-1, ?)
If you want to become a Fullstack Scala Developer, you should learn the following technology stack:
NOTE:- In Scala, Extractor follows Extractor Design Pattern. If you want to learn it in depth, please go through my Scala Tutorial (Most of the posts follows this pattern: Scala xxxx In Depth where xxxx is a concept like Extractor). That’s it all about “Scala Advanced Interview Questions and Answers”. We will discuss some more Scala Interview Questions and Answers in my coming posts. Please drop me a comment if you like my post or have any issues/suggestions.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.
Sign up for Infrastructure as a Newsletter.
Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.
Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.
scala> var list1 = List(3,4,5) list1: List[Int] = List(3, 4, 5) scala> val list2 = List(1,2) ::: list1 list2: List[Int] = List(1, 2, 0, 1, 2, 3, 4) Above example output is incorrect. it should be List(1, 2, 3, 4, 5)
- Ankit
just saying slick is FRM(function relation mapping ) and I learned this in a hard way :-)
- Rachit Solanki