Scala

Question 1

object keyword

Answer 1

Combines a few concepts from Java.

It’s like a singleton class in Java in the sense that it’s a class that has exactly one instance. Unlike Java, there’s no need to make the methods static. (Scala has no static keyword.)

It’s like an anonymous class in the sense that you declare and instantiate the class at the same time.

Objects are created lazily (like a val variable).

An object and a class with the same name are called companions and can access each other’s private methods.

One of the most common use cases for objects is to create utility methods or factory methods to return an instance of the class.

https://docs.scala-lang.org/tour/singleton-objects.html

Question 2

When to create a companion object?

Answer 2

To isolate the static methods of a class or create a factory method

Question 3

Unit

Answer 3

Equivalent of void. Subtype of anyval.

Question 4

Concurrency vs Parralism

Answer 4

Concurreny - when several computations execute sequentially during overlapping time periods. Concurrency abstractions - threads, semaphore, synchronization. Future.
Parallelism - Processes are executed simultaneously.

Question 5

Monad

Answer 5

• Wraps another object in scala
• Structures that represent sequential computations
• The output of the computation is an input to other calculations
• Provides identity through unit
• Bind via flatMap

Question 6

Lambda Calculus

Answer 6

• Literal translation is “Functional Analysis”

- System of treating problems by agreed on symbols as a method of calculation

Question 7

Var vs Val

Answer 7

Var - ordinary java variable. Mutable declaration.
Val - once variable is declared with val the reference cannot be changed to point to another reference. Immutable declaration. Similar to final in Java.

Question 8

Closure

Answer 8

The return value of the function depends on the value of one or more variables declared outside the function

Question 9

Future

Answer 9

• Represents future value of a task once it has completed. Does not represent the asynchronous computation that is spawned when a future is created.
• Allows async programming through chaining of operations
• Supports callback functions like onComplete, OnFailure, and onSuccess
• Java’s future class does not provide promises or callbacks

Question 10

Future vs Promise

Answer 10

Two different sides of a pipe. On the promise side, data is pushed in. On the Future side, data is pulled out.

Question 11

Traits

Answer 11

• Enable multiple inheritance. A trait can only extend one class but a class can have multiple traits.
• Traits cannot be instantiated.
• Often used for dependency injection.
• Useful for declaring generic types with abstract methods
• Use the extends keyword to extend a trait. Then implement any abstract methods using the override keyword.

https://docs.scala-lang.org/tour/traits.html

Question 12

Currying

Answer 12

Technique of transforming a function with multiple arguments into a chain of functions each with a single argument.
Makes it easier to defer execution and reuse functions

Question 13

Case classes

Answer 13

Good for modeling immutable data and pattern matching (substitute for switch and long if/else blocks in Java)

• No need to create a constructor or declare parameters explicitly. Both are done by default.
• Serializable by default
• For equality, instances are compared by structure (are the values of the fields identical?), not by reference equality.

Question 14

Implicit parameter

Answer 14

optional parameter with default values

Question 15

Tail recursion

Answer 15

The scala compiler optimizes recursive functions so that they don’t allocate new stack space

Question 16

Streams

Answer 16

Like a list but with lazy evaluation

Question 17

Implicit functions

Answer 17

• Convert one type to another
• Like casting but called automatically by the compiler
• Bad practice, especially when implicits are visible outside the class
• Used to add behavior to a type via a practice called pimping

Question 18

Sealed traits and classes

Answer 18

Subtypes must be declared in the same file. When all subtypes are known, you don’t need a case _ => catch all case.

Question 19

Monoid

Answer 19

• Monoids combine n things into 1 thing and support the n=0 case.
• A monoid is any type that has an operation taking two arguments of that type and returning a value of that type.
• The operation must be associative.
• The monoid must support 0. In other words, an operation where combining one thing and zero return the first thing unchanged.

Question 20

Apply

Answer 20

Factory method that allows you to skip new

Question 21

Partial Function

Answer 21

• A regular function must return a value for the entire range of valid inputs
• A partial function does not have to handle all possible inputs that could be passed to it.
• This is especially useful for traits with many concrete implementations (case classes). You don’t have to address every case class in the partial function.

The collect() function in Scala collections is ax example of a partial function.

It accepts a partial function of whatever is in the collection, and returns a list of whatever is returned. The result of which is you can compress a .filter().map() into something more dignified and elegant.

val maybeNumbers = Seq(Some(1), Some(34), None, Some(-87), None)

val meh: Seq[Int] = maybeNumbers.filter(.isDefined).map(.get)
val elegant: Seq[Int] = maybeNumbers.collect { case Some(i) => i }