Interview Questions and Answers

Apache Spark is an open-source distributed computing system that provides fast and general-purpose cluster computing for big data processing and analytics.

Example:

SparkContext sc = new SparkContext("local", "SparkExample");

SparkContext is the entry point for Spark functionality and represents the connection to the Spark cluster. It coordinates the execution of operations on the cluster.

Example:

val sc = new SparkContext("local", "SparkExample")

The Spark Driver is the program that runs the main() function and creates the SparkContext. It coordinates the execution of tasks on the Spark Executors and collects results from them.

Example:

object MyApp {
  def main(args: Array[String]): Unit = {
    val sc = new SparkContext("local", "MyApp")
  }
}

A DataFrame is a distributed collection of data organized into named columns, similar to a relational table. An RDD (Resilient Distributed Dataset) is a low-level abstraction representing a distributed collection of objects.

Example:

val df = spark.read.json("/path/to/data.json")

Transformations are operations that create a new RDD, while actions are operations that return a value to the driver program or write data to an external storage system.

Example:

val mappedRDD = inputRDD.map(x => x * 2)
val result = mappedRDD.reduce((x, y) => x + y)

Spark's lineage graph (DAG) is a directed acyclic graph that represents the sequence of transformations and actions on RDDs. It helps in recovering lost data in case of node failure.

Example:

val filteredRDD = inputRDD.filter(x => x > 0)
filteredRDD.toDebugString

Partitions are basic units of parallelism in Spark. They represent the logical division of data across the nodes in a cluster, and each partition is processed independently.

Example:

val inputRDD = sc.parallelize(Seq(1, 2, 3, 4, 5), 2)

A Spark Executor is a process responsible for executing tasks on a worker node. Executors are launched at the beginning of a Spark application and run tasks until the application completes or encounters an error.

Example:

spark-submit --master yarn --deploy-mode client --num-executors 3 mySparkApp.jar

A Broadcast variable is a read-only variable cached on each worker node. It is used to efficiently distribute large read-only data structures, such as lookup tables, to all tasks in a Spark job.

Example:

val broadcastVar = sc.broadcast(Array(1, 2, 3))

Spark SQL is a Spark module for structured data processing. It provides a programming interface for data manipulation using SQL, as well as a DataFrame API for processing structured and semi-structured data.

Example:

val df = spark.sql("SELECT * FROM table")

You can persist an RDD using the persist() or cache() method. It allows you to store the RDD's data in memory or on disk for faster access.

Example:

val cachedRDD = inputRDD.persist(StorageLevel.MEMORY_ONLY)

Narrow transformations involve operations where each input partition contributes to only one output partition. Wide transformations involve operations where multiple input partitions contribute to multiple output partitions.

Example:

Narrow: map, filter
Wide: groupByKey, reduceByKey

Spark Streaming is an extension of the core Spark API that enables scalable, high-throughput, fault-tolerant stream processing of live data streams. It allows processing real-time data using batch processing capabilities of Spark.

Example:

val streamingContext = new StreamingContext(sparkContext, Seconds(1))

Spark uses Java's Object Serialization to serialize data between the Spark Driver and Executors. Efficient serialization is crucial for optimizing data transfer and reducing network overhead.

Example:

sparkConf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")

An accumulator is a variable that can be added to and is used in Spark to implement counters and sums in a parallel and fault-tolerant manner across distributed tasks.

Example:

val accumulator = sc.longAccumulator("MyAccumulator")

The Spark DAG represents the logical execution plan of transformations and actions in a Spark application. It is a graph of stages, where each stage contains a sequence of tasks that can be executed in parallel.

Example:

val dag = inputRDD.map(x => x * 2).toDebugString

A task is the smallest unit of work in Spark, representing the execution of a transformation or action on a partition of data. Tasks are scheduled by the Spark Scheduler on Spark Executors.

Example:

val taskResult = executor.runTask(taskID, taskInfo)

Spark MLlib is Spark's machine learning library, providing scalable implementations of various machine learning algorithms and tools for building and evaluating machine learning models.

Example:

val model = new RandomForestClassifier().fit(trainingData)

Lazy evaluation is a strategy in which the execution of operations is delayed until the result is actually needed. This helps in optimizing the execution plan.

Example:

val filteredRDD = inputRDD.filter(x => x > 0)
filteredRDD.count()

Spark achieves fault tolerance through lineage information (DAG) and recomputing lost data from the original source. If a partition of an RDD is lost, Spark can recompute it using the lineage information.

Example:

val resilientRDD = originalRDD.filter(x => x > 0)

The Spark Shuffle operation redistributes data across partitions during certain transformations, such as groupByKey or reduceByKey. It is a costly operation that involves data exchange and can impact performance.

Example:

val groupedRDD = inputRDD.groupByKey()

Spark offers in-memory processing, higher-level abstractions like DataFrames, and iterative processing, making it faster and more versatile than Hadoop MapReduce.

Example:

SparkContext sc = new SparkContext("local", "SparkExample")

Data skewness occurs when certain keys have significantly more data than others. Spark handles it by using techniques like data pre-partitioning or using advanced algorithms like map-side aggregation.

Example:

val skewedData = inputRDD.groupByKey(numPartitions)

Spark aims to schedule tasks on nodes that have a copy of the data to minimize data transfer over the network. This is achieved by using data locality-aware task scheduling.

Example:

sparkConf.set("spark.locality.wait", "2s")