Scala Interview Questions India 2026: Functional Programming, Akka, and Apache Spark

Scala runs on the JVM and interoperates fully with Java, but it adds powerful functional programming features that change how you write code.

Scala vs Java:

1. val vs var: val declares an immutable reference (like Java final); var declares a mutable reference. Prefer val — immutability prevents bugs in concurrent code
2. Type inference: Scala infers types so you do not need to write them explicitly: val name = 'Alice' (type String is inferred)
3. Everything is an expression: if/else, match, and try/catch all return values in Scala
4. No checked exceptions: Scala does not have checked exceptions (unlike Java)
5. Semicolons are optional in Scala

Functional programming concepts:

1. Pure functions: a function with no side effects; given the same inputs, always returns the same output. Easier to test and reason about
2. Immutability: prefer immutable data structures; Scala collections are immutable by default (List, Map, Set from scala.collection.immutable)
3. Higher-order functions: functions that take other functions as parameters or return functions: list.map(x => x * 2), list.filter(x => x > 0), list.flatMap, list.fold
4. Function composition: combine small functions into larger ones: val transform = f andThen g (apply f first, then g)
5. Currying: transforming a function with multiple arguments into a sequence of functions each taking one argument

Pattern matching: 11. match expressions are Scala's powerful switch statement that can deconstruct data structures: case class Point(x: Int, y: Int) point match { case Point(0, 0) => 'origin' case Point(x, 0) => s'on x-axis at $x' case Point(0, y) => s'on y-axis at $y' case Point(x, y) => s'at ($x, $y)' } 12. Pattern matching works on lists, tuples, case classes, and sealed trait hierarchies 13. Sealed traits: a sealed trait can only be extended in the same file; the compiler warns if a match is not exhaustive

Case classes and traits are the building blocks of Scala data modelling and polymorphism.

Case classes:

1. case class Person(name: String, age: Int) — immutable data holder
2. Automatically generated: equals (structural equality), hashCode, toString, copy, and companion object with apply/unapply
3. copy method: val older = person.copy(age = person.age + 1) — creates a new instance with one field changed
4. No need for new keyword: val p = Person('Alice', 30)
5. Case classes work perfectly with pattern matching because of the unapply extractor

Traits:

1. Traits are like Java interfaces but can have concrete method implementations and state
2. A class can mix in multiple traits (unlike Java's single-class inheritance): class Dog extends Animal with Runnable with Serializable
3. Trait linearisation: Scala resolves multiple trait inheritance via a deterministic linearisation order (right to left in the extends clause)
4. Abstract methods in traits must be implemented by concrete classes or other traits

Option, Either, and Try for error handling:

1. Option[A]: represents an optional value; Some(value) or None; avoids null pointer exceptions
2. map, flatMap, and getOrElse work on Option: option.getOrElse(defaultValue)
3. Either[L, R]: Left conventionally represents an error; Right represents success; used for functional error handling
4. Try[A]: wraps a computation that may throw an exception; Success(value) or Failure(exception)

Collections:

1. Immutable collections (default): List (linked list; fast prepend), Vector (indexed; fast random access), Map, Set
2. Mutable collections (scala.collection.mutable): ArrayBuffer, HashMap — use sparingly
3. Common transformations: map (transform each element), filter (keep elements matching a predicate), flatMap (map then flatten), fold/reduce (aggregate), groupBy (group elements by a key), zip (combine two collections element-by-element)

Akka and Spark are the two most common Scala frameworks tested in Indian data engineering and backend interviews.

Akka Actor Model basics:

1. The Actor Model is a concurrency model where actors are the basic unit of computation; actors communicate only by sending messages (no shared mutable state)
2. ActorSystem: the container for all actors in an application
3. ActorRef: a reference to an actor; you send messages to an ActorRef, not directly to an actor
4. tell (!): fire-and-forget message sending: actorRef ! message
5. ask (?): sends a message and returns a Future with the response
6. Actors process messages from their mailbox sequentially (one at a time); no synchronisation is needed inside an actor
7. Supervision: parent actors supervise child actors; a supervisor decides what to do when a child fails (restart, stop, escalate)
8. Akka Streams: reactive stream processing on top of the actor model; provides backpressure

Apache Spark with Scala:

1. SparkSession: the entry point for all Spark functionality; replaces SparkContext + SQLContext + HiveContext
2. RDDs (Resilient Distributed Datasets): the low-level distributed collection API; fault-tolerant; partitioned across the cluster
3. DataFrames: distributed collections of rows with named columns; similar to a relational table; optimised by the Catalyst query optimiser
4. Datasets[T]: type-safe DataFrames specific to Scala and Java; Dataset[Row] is the same as DataFrame
5. Transformations are lazy: map, filter, groupBy build a logical plan; no computation happens until an action is called
6. Actions trigger execution: collect, count, show, write
7. Narrow vs wide transformations: narrow (map, filter) do not require data shuffle; wide (groupBy, join, repartition) require a shuffle across the network — the most expensive Spark operation
8. Partitioning: repartition(n) creates exactly n partitions (involves a full shuffle); coalesce(n) reduces partitions without a full shuffle (use to reduce partition count before writing)
9. Caching: df.cache() or df.persist(StorageLevel.MEMORYANDDISK) stores a DataFrame in memory for reuse across multiple actions
10. Broadcast variables: broadcastVar = sc.broadcast(largeMap) — sends a read-only variable to all executor nodes once, avoiding re-sending it with every task