Kappa architecture (streaming only) in Hadoop - Time & Space Complexity

Time Complexity: Kappa architecture (streaming only)

O(n)

Understanding Time Complexity

We want to understand how the time needed to process data grows when using Kappa architecture for streaming data.

How does the system handle more data as it keeps coming in?

Scenario Under Consideration

Analyze the time complexity of the following streaming processing code snippet.

// Pseudocode for streaming data processing in Kappa architecture
stream = readFromKafka(topic)
processedStream = stream.map(record => transform(record))
processedStream.foreachBatch(batch => {
  batch.writeToStorage()
})

This code reads data continuously from a stream, transforms each record, and writes batches to storage.

Identify Repeating Operations

Look at what repeats as data flows in.

• Primary operation: Processing each record in the stream (map transformation).
• How many times: Once per incoming record, continuously as data arrives.

How Execution Grows With Input

As more records come in, the system processes each one individually.

Input Size (n)	Approx. Operations
10	10 transformations
100	100 transformations
1000	1000 transformations

Pattern observation: The number of operations grows directly with the number of records.

Final Time Complexity

Time Complexity: O(n)

This means the time to process data grows linearly with the number of incoming records.

Common Mistake

[X] Wrong: "Streaming processing time stays the same no matter how much data arrives."

[OK] Correct: Each new record needs processing, so more data means more work and more time.

Interview Connect

Understanding how streaming systems scale with data helps you explain real-time data processing clearly and confidently.

Self-Check

"What if the transform step became more complex and took longer per record? How would the time complexity change?"

Practice

1.

What is the main idea behind the Kappa architecture in data processing?

easy

A. Store data in batches and process later

B. Process data only once as a continuous stream

C. Use separate systems for batch and streaming data

D. Process data multiple times for accuracy

Solution

1. Step 1: Understand Kappa architecture concept

   Kappa architecture focuses on processing data as a stream only once, avoiding batch processing.

2. Step 2: Compare with other architectures

   Unlike Lambda architecture, Kappa does not separate batch and streaming layers.

3. Final Answer:

   Process data only once as a continuous stream -> Option B

4. Quick Check:

   Kappa = single stream processing [OK]

Hint: Kappa means one stream, one processing path [OK]

Common Mistakes:

• Confusing Kappa with Lambda architecture
• Thinking Kappa uses batch processing
• Assuming multiple processing passes

2.

Which of the following is a correct component used in a typical Kappa architecture setup?

A) Separate batch and speed layers

B) Hadoop MapReduce for batch jobs

C) HDFS for storing batch data

D) Kafka for streaming data

easy

A. Separate batch and speed layers

B. Hadoop MapReduce for batch jobs

C. HDFS for storing batch data

D. Kafka for streaming data

Solution

1. Step 1: Identify streaming components in Kappa

   Kappa architecture uses streaming tools like Kafka to handle real-time data.

2. Step 2: Exclude batch-specific components

   Batch tools like MapReduce or HDFS batch storage are not part of Kappa's streaming-only design.

3. Final Answer:

   Kafka for streaming data -> Option D

4. Quick Check:

   Kappa uses Kafka, not batch tools [OK]

Hint: Kappa = streaming tools like Kafka only [OK]

Common Mistakes:

• Choosing batch tools like MapReduce
• Selecting batch storage like HDFS
• Thinking Kappa has separate batch layers

3.

Consider this simplified streaming code snippet using Kafka and Spark in a Kappa architecture:

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('KappaExample').getOrCreate()

# Read stream from Kafka topic
stream_df = spark.readStream.format('kafka') \
  .option('kafka.bootstrap.servers', 'localhost:9092') \
  .option('subscribe', 'events') \
  .load()

# Select and cast value to string
value_df = stream_df.selectExpr('CAST(value AS STRING)')

# Write stream to console
query = value_df.writeStream.outputMode('append').format('console').start()

query.awaitTermination()

What will this code do?

medium

A. Continuously print new Kafka messages from 'events' topic to console

B. Read all past Kafka messages once and stop

C. Write data back to Kafka topic 'events'

D. Throw an error due to missing schema

Solution

1. Step 1: Understand the streaming read

   The code reads a continuous stream from Kafka topic 'events' using Spark Structured Streaming.

2. Step 2: Analyze output mode and sink

   Output mode 'append' with console sink means new messages print continuously to console.

3. Final Answer:

   Continuously print new Kafka messages from 'events' topic to console -> Option A

4. Quick Check:

   Streaming read + console output = continuous print [OK]

Hint: Streaming read + console output = live print [OK]

Common Mistakes:

• Thinking it reads all past messages once
• Assuming it writes back to Kafka
• Expecting schema error without explicit schema

4.

Identify the error in this Kappa architecture streaming code snippet using Kafka and Spark:

stream_df = spark.readStream.format('kafka') \
  .option('kafka.bootstrap.servers', 'localhost:9092') \
  .option('subscribe', 'events') \
  .load()

value_df = stream_df.selectExpr('CAST(value AS STRING)')

query = value_df.writeStream.outputMode('complete').format('console').start()

query.awaitTermination()

What is the problem?

medium

A. Output mode 'complete' is invalid for streaming without aggregation

B. Missing schema definition causes failure

C. Kafka server address is incorrect

D. No error, code runs fine

Solution

1. Step 1: Check output mode usage

   Output mode 'complete' requires aggregation queries to output full results.

2. Step 2: Analyze query type

   This query only selects and casts values without aggregation, so 'complete' mode is invalid.

3. Final Answer:

   Output mode 'complete' is invalid for streaming without aggregation -> Option A

4. Quick Check:

   'complete' mode needs aggregation [OK]

Hint: 'complete' mode only with aggregation queries [OK]

Common Mistakes:

• Assuming missing schema causes error
• Thinking Kafka address is wrong
• Believing code runs without error

5.

You want to build a real-time dashboard using Kappa architecture that shows the count of events per user from a Kafka stream. Which approach fits best?

A) Use two separate systems: one for batch counts and one for streaming counts, then merge results.

B) Store Kafka data in HDFS, run daily batch jobs to count events per user, then update dashboard.

C) Use Spark Structured Streaming to read Kafka, group by user, count events, and update dashboard continuously.

D) Read Kafka stream once and save raw data only, no processing.

hard

A. Use two separate systems: one for batch counts and one for streaming counts, then merge results.

B. Store Kafka data in HDFS, run daily batch jobs to count events per user, then update dashboard.

C. Use Spark Structured Streaming to read Kafka, group by user, count events, and update dashboard continuously.

D. Read Kafka stream once and save raw data only, no processing.

Solution

1. Step 1: Understand Kappa architecture goal

   Kappa architecture processes data as a stream only, avoiding batch layers.

2. Step 2: Choose streaming aggregation for real-time dashboard

   Using Spark Structured Streaming to group and count events per user fits Kappa's streaming-only design and real-time needs.

3. Step 3: Exclude batch or hybrid approaches

   Batch jobs or separate batch/stream systems contradict Kappa principles.

4. Final Answer:

   Use Spark Structured Streaming to read Kafka, group by user, count events, and update dashboard continuously. -> Option C

5. Quick Check:

   Real-time + streaming aggregation = Use Spark Structured Streaming to read Kafka, group by user, count events, and update dashboard continuously. [OK]

Hint: Real-time dashboard needs streaming aggregation [OK]

Common Mistakes:

• Choosing batch processing for real-time needs
• Using hybrid batch and streaming systems
• Not processing data, just storing raw stream