3. What advantages does Spark offer over Hadoop MapReduce?

·      Due to the availability of in-memory processing, Spark implements the processing around 10 to 100 times faster than Hadoop MapReduce whereas MapReduce makes use of persistence storage for any of the data processing tasks.
·      Unlike Hadoop, Spark provides inbuilt libraries to perform multiple tasks from the same core as batch processing, Steaming, Machine learning, Interactive SQL queries. However, Hadoop only supports batch processing.
·      Hadoop is highly disk-dependent whereas Spark promotes caching and in-memory data storage.
·      Spark can perform computations multiple times on the same dataset. This is called iterative computation while there is no iterative computing implemented by Hadoop
 
4. Enumerate the various components of the Spark Ecosystem?

Spark Core – Base engine for large-scale parallel and distributed data processing

Spark SQL – Integrates relational processing with Spark’s functional programming API

Spark Streaming – Used for processing real-time streaming data

MLlib – Used for applying machine learning

GraphX – Implements Graphs and graph-parallel computation

5. What are the various functions of Spark Core?
 
Spark Core acts as the base engine for large-scale parallel and distributed data processing. It is the distributed execution engine used in conjunction with the Java, Python, and Scala APIs that offer a platform for distributed ETL (Extract, Transform, Load) application development.
Various functions of Spark Core are:
·      Distributing, monitoring, and scheduling jobs on a cluster
·      Interacting with storage systems
·      Memory management and fault recovery
Furthermore, additional libraries built on top of the Spark Core allow it to diverse workloads for machine learning, streaming, and SQL query processing.
 
6. Mention various modes of running Spark

Ø local
Ø clustered
·      Spark Standalone
·      Spark on Hadoop YARN
·      Spark on Apache Mesos
 
7. What is RDD?
 
RDD is the acronym for Resilient Distributed Dataset. It is the Spark’s primary core abstraction.
RDD is a fault-tolerant collection of operational elements that run in parallel. The partitioned data in RDD is immutable and distributed in nature.
Fundamentally, RDDs are portions of data that are stored in the memory distributed over many nodes. These RDDs are lazily evaluated in Spark, which is the main factor contributing to the hastier speed achieved by Apache Spark.

8.  How can we create RDD in Apache Spark?
There are two ways of creating an RDD in Apache Spark:
·      By parallelizing a collection in the driver program. It makes use of SparkContext’s parallelize() method.
·      By means of loading an external dataset from some external storage, including HDFS, S3, HBase and shared file system.

9. Define Partitions in Apache Spark.
 
As the name suggests, partition is a smaller and logical division of data like ‘split’ in MapReduce. It is a logical chunk of a large distributed data set.
Partitioning is the process to derive logical units of data to speed up the processing process. Spark manages data using partitions that help parallelize distributed data processing with minimal network traffic for sending data between executors. By default, Spark tries to read data into an RDD from the nodes that are close to it. Everything in Spark is a partitioned RDD.

10. What operations does RDD support?

RDDs support two types of operations:
Transformations:
Transformations are operations on RDD that create one or more new RDDs. Examples include map, filter, reduceByKey etc. In other words, transformations are functions that take an RDD as the input and produce one or more RDDs as the output. There is no change in the input RDD, but it always produces one or more new RDDs by applying the computation they represent.

Transformations are lazy, i.e. they are not executed immediately. Only after calling an action, transformations are executed.
Actions:
Actions return final results of the RDD computations. Actions triggers execution using lineage graph to load the data into original RDD, carry out all intermediate transformations and return final results to Driver program or write it out to file system. Examples included collect, count, take etc.
 
11. What are the types of Apache Spark transformations?

There are fundamentally two types of transformations:
Narrow Transformations: Narrow transformations are the result of map, filter and such that is from the data from a single partition only, i.e. it is self-sustained.
            An output RDD has partitions with records that originate from a single partition in the parent RDD. Only a limited subset of partitions used to calculate the results
Wide Transformations: Wide transformations are the result of groupByKey and reduceByKey. The data required to compute the records in a single partition may reside in many partitions of the parent RDD. Wide transformation results in a new stage with a new set of partitions in the stage.

12. What is RDD Lineage?
 
An RDD Lineage Graph (aka RDD operator graph) is a graph of all the parent RDDs of an RDD. It is built as a result of applying transformations to the RDD and creates a logical execution plan.
            An RDD lineage graph is hence a graph of what transformations need to be executed after an action has been called.
            Lineage graph is used to recover RDDs from a failure.

13. What is Spark Context in Apache Spark?
 
A SparkContext is a client of Spark’s execution environment and it acts as the master of the Spark application. SparkContext sets up internal services and establishes a connection to a Spark execution environment. You can create RDDs, accumulators and broadcast variables, access Spark services and run jobs (until SparkContext stops) after the creation of SparkContext. Only one SparkContext may be active per JVM. You must stop () the active SparkContext before creating a new one.
 
In Spark shell, a special interpreter-aware SparkContext is already created for the user, in the variable called sc.
The first step of any Spark driver application is to create a SparkContext. The SparkContext allows the Spark driver application to access the cluster through a resource manager. The resource manager can be YARN, or Spark’s Cluster Manager.

14.  By Default, how many partitions are created in RDD in Apache Spark?
 
By Default, Spark creates one Partition for each block of the file (for HDFS). Default block size for HDFS block is 64 MB (Hadoop Version 1) / 128 MB (Hadoop Version 2). However, one can explicitly specify the number of partitions to be created.

15. What is the difference between RDD Lineage and DAG?
 
An RDD Lineage is a graph of all the parent RDDs of an RDD. We also call it an RDD operator graph or RDD dependency graph. It is built as a result of applying transformation to the RDD and creates a logical execution plan.
An RDD lineage graph is hence a graph of what transformations need to be executed after an action has been called.
RDD lineage is accessed by calling toDebugString() method on a RDD.
 
Whereas, DAG represents the physical execution plan, known as DAG of stages.
DAG in Apache Spark is a combination of Vertices as well as Edges. In DAG vertices represent the RDDs and the edges represent the Operation to be applied on RDD. Every edge in DAG is directed from earlier to later in a sequence. When we call an Action, the created DAG is submitted to DAG Scheduler which further splits the graph into the stages of the tasks.
 
16. What is the role of Spark Driver in Spark application?
 
A Spark driver (aka an application’s driver process) is a JVM process that hosts SparkContext for a Spark application.
·      It is the cockpit of jobs and tasks execution (using DAGScheduler and Task Scheduler). It hosts Web UI for the environment.
·      It splits a Spark application into tasks and schedules them to run on executors.
·      A driver is where the task scheduler lives and spawns’ tasks across workers.
·       A driver coordinates workers and overall execution of tasks.

17. Difference between map() and flatMap() in Spark?
 
map() and flatMap() are similar, in the sense they take a line from the input RDD and apply a function on it. The way they differ is that the function in map returns only one element, while function in flatMap can return a list of elements (0 or more) as an iterator.
Also, the output of the flatMap() is flattened. Although the function in flatMap returns a list of elements, the flatMap returns an RDD which has all the elements from the list in a flat way (not a list).
map(func) It returns a new RDD by applying given function to each element of the RDD. Function in map returns only one item.
flatMap(func) Similar to map, it returns a new RDD by applying a function to each element of the RDD, but output is flattened.

18. Difference between groupByKey() and reduceByKey() in Spark?

groupByKey – When called on a dataset of (K, V) pairs, returns a dataset of (K, Iterable) pairs.
When a groupByKey() is called on a RDD pair the data in the partitions are shuffled over the network to form a key and list of values. This is a costly operation particularly when working on large data set. This might also cause trouble when the combined value list is huge to occupy in one partition. In this case a disk spill will occur.
 
reduceByKey(function) – When called on a dataset of (K, V) pairs, returns a dataset of (K, V) pairs where the values for each key are aggregated using the given reduce function. The function should be able to take arguments of some type and it returns same result data type.
Unlike groupByKey , reduceByKey does not shuffle data at the beginning. As it knows the reduce operation can be applied in same partition first, only result of reduce function is shuffled over network. This cause significant reduction in traffic over network.

19. Difference between Cache and Persist in Spark?
 
Cache and Persist both are optimization techniques for Spark computations.
Cache is a synonym of Persist with MEMORY_ONLY storage level i.e., using caching, we can save intermediate results in memory only when needed.
Persist marks an RDD for persistence using storage level which can be MEMORY, MEMORY_AND_DISK, MEMORY_ONLY_SER, MEMORY_AND_DISK_SER, DISK_ONLY, MEMORY_ONLY_2, MEMORY_AND_DISK_2.
Just because you can cache an RDD in memory doesn’t mean you should blindly do so. Depending on how many times the dataset gets accessed and the amount of work involved in doing so, re-computation can be faster by the increased memory pressure.
It should go without saying that if you only read a dataset once there is no point in caching it, it will make your job slower.
 
20. What are shared variables in Spark?
 
Shared variables are the variables that are required to be used by many functions & methods in parallel. Shared variables can be used in parallel operations like transformations.
Spark segregates the job into the smallest possible operation, a task, running on different nodes and each having a copy of all the variables of the Spark job. Any changes made to these variables doesn’t reflect in the driver program and hence to overcome this limitation Spark provides two special type of shared variables – Broadcast Variables and Accumulators.
Broadcast variables:
Used to cache a value in memory on all nodes. Here only one instance of this read-only variable is shared between all computations throughout the cluster.
Spark sends the broadcast variable to each node concerned by the related task. After that, each node caches it locally in serialised form. Now before executing each of the planned tasks instead of getting values from the driver system retrieves them locally from the cache.
Broadcast variables are immutable, distributed i.e., broadcasted to the cluster and fit in memory.
Accumulators:
As its name suggests Accumulators main role is to accumulate values. The accumulators are variables that are used to implement counters and sums. Spark provides accumulators of numeric type only. Users can create named or unnamed accumulators.
Unlike Broadcast variables, accumulators are writable. However, written/updated values can be only read in driver program. This is the reason why accumulators work well as data aggregators.

21. Difference between map() and mapPartitions() in Spark?

map() – It returns a new RDD by applying the given function to each element of the RDD. The function in the map returns only one item.
mapPartitions() – This is a specialized map that is called only once for each partition.That is, the function runs separately on each partition (block) of the RDD, so the function must be of type Iterator<T> ⇒ Iterator<U> when running on an RDD of type T.
map() exercises function at per element/record level whereas mapPartitions() exercises function at the partition level.

22. Difference between coalesce() and repartition() in Spark?

coalesce uses existing partitions to minimize the amount of data that’s shuffled. That is, it works with existing partitions and shuffle a subset of them.
repartition creates new partitions and does a full shuffle. That is, it ignores existing partitions and create new ones.
coalesce results in partitions with different amounts of data (sometimes partitions that have much different sizes) and repartition results in roughly equal sized partitions.
 
In a simple way, coalesce is only used to decrease the number of partitions, no shuffling of data it just compress the partitions i.e., adjust within the existing partitions.
repartition can be used to both decrease and increase the number of partitions as full shuffling takes place.
 
23. What does “Stage Skipped” mean in Apache Spark web UI?
 
Stage Skipped means that data has been fetched from cache and re-execution of the given stage is not required. Basically, the stage has been evaluated before, and the result is available without re-execution. Whenever there is shuffling involved Spark automatically caches generated data.
 
24.  Will rdd1.join(rdd2) cause a shuffle to happen if rdd1 and rdd2 have the same partitioner?
 
No. If two RDDs have the same partitioner, there will be no shuffle caused by the join.
However, keep in mind that the lack of a shuffle does not mean that no data will have to be moved between nodes. It’s possible for two RDDs to have the same partitioner (be co-partitioned) yet have the corresponding partitions located on different nodes (not be co-located).
This situation is still better than doing a shuffle, but it’s something to keep in mind. Co-location can improve performance but is hard to guarantee.

25. In a given spark program, how will you identify whether a given operation is Transformation or Action?
 
One can identify the operation based on the return type –
i) The operation is an action, if the return type is other than RDD.
ii) The operation is transformation, if return type is same as RDD.

26. What is Lazy evaluation in Spark?
 
Spark is intellectual in the way it operates on data. When you tell Spark to operate on a given dataset, it heeds the instructions and makes a note of it, so that it does not forget – but it does nothing, unless asked for the final result. When a transformation like map () is called on a RDD-the operation is not performed immediately. Transformations in Spark are not evaluated till you perform an action. This helps optimize the overall data processing workflow.
 
27. What do you understand by Pair RDD?
 
Special operations can be performed on RDDs in Spark using key/value pairs and such RDDs are referred to as Pair RDDs.
Pair RDDs allow users to access each key in parallel. Pair RDDs have a reduceByKey () method that collects data based on each key and a join () method that combines different RDDs together, based on the elements having the same key.  
28. How Can You Minimize Data Transfers When Working with Spark?
 
Minimizing data transfers and avoiding shuffling helps write spark programs that run in a fast and reliable manner. The various ways in which data transfers can be minimized when working with Apache Spark are:
·      Using Broadcast Variable- Broadcast variable enhances the efficiency of joins between small and large RDDs.
·      Using Accumulators – Accumulators help update the values of variables in parallel while executing.
·      The most common way is to avoid operations ByKey, repartition or any other operations which trigger shuffles.



29. What is Spark SQL? List the functions of Spark SQL.
 
Spark SQL is a Spark interface to work with structured as well as semi-structured data. Through this module, Spark executes relational SQL queries on the data.
The core of the component supports an altogether different RDD called SchemaRDD, composed of rows objects and schema objects defining data type of each column in the row. It is like a table in relational database.
 
Spark SQL is capable of:
·      Loading data from a variety of structured sources
·      Querying data using SQL statements, both inside a Spark program and from external tools that connect to Spark SQL through standard database connectors (JDBC/ODBC). For instance, using business intelligence tools like Tableau
·      Providing rich integration between SQL and regular Python/Java/Scala code, including the ability to join RDDs and SQL tables, expose custom functions in SQL, and more

30. What is the advantage of a Parquet file?
 
Parquet file is a columnar format file that helps –
·      Limit I/O operations
·      Consumes less space
·      Fetches only required columns.

31. Difference between Spark SQL and Hive

·      Spark SQL is faster than Hive.
·      Any Hive query can easily be executed in Spark SQL but vice-versa is not true.
·      Spark SQL is a library whereas Hive is a framework.
·      It is not mandatory to create a metastore in Spark SQL, but it is mandatory to create a Hive metastore.
·      Spark SQL automatically infers the schema whereas in Hive schema needs to be explicitly defined.

32. What is Catalyst optimizer in Apache Spark?
 
The optimizer used by Spark SQL is Catalyst optimizer. Catalyst optimizer optimizes the logical plan of the SQL queries written in Spark SQL and DataFrame DSL. It’s a set of rules which apply on the SQL query to rewrite it in better way to gain performance.