Debugging, Testing, and Optimization Questions

Core engineering skills for identifying, diagnosing, testing, and improving code correctness and performance. Covers approaches to finding and fixing bugs including reproducible test case construction, logging, interactive debugging, step through debugging, and root cause analysis. Includes testing strategies such as unit testing, integration testing, regression testing, test driven development, and designing tests for edge cases, boundary conditions, and negative scenarios. Describes performance optimization techniques including algorithmic improvements, data structure selection, reducing time and space complexity, memoization, avoiding unnecessary work, and parallelism considerations. Also covers measurement and verification methods such as benchmarking, profiling, complexity analysis, and trade off evaluation to ensure optimizations preserve correctness and maintainability.

EasyTechnical

67 practiced

What is test driven development (TDD)? Describe a short workflow for adding a new feature using TDD in an agile sprint, including how you would balance failing tests, refactoring, and collaboration with product/design stakeholders.

MediumSystem Design

62 practiced

Design a lightweight profiling strategy to measure request latency distribution for a web API that serves 10k RPS. Discuss sampling rate, overhead limits, where to collect traces, and how to aggregate and visualize hotspots without storing full traces for every request.

Sample Answer

Requirements & constraints:- Measure request latency distribution and surface hotspots at 10k RPS with low overhead (<1–2% CPU, <1ms tail added).- Avoid storing full traces for every request; keep storage & cost manageable.- Actionable output: P95/P99/P999, latency histogram, top latency contributors by service/span.

High-level approach:1. Hybrid sampling: - Deterministic lightweight sampling: sample 1% of requests (100 RPS) for full traces. - Adaptive reservoir for tail-focused sampling: keep the top-N slow requests per minute by latency (e.g., top 200/min) across all instances using local tracking. - Rare-event amplification: always sample error responses and requests with abnormal resource usage.

2. Where to collect: - Collect lightweight timing metrics in-process at entry/exit and per major spans (DB, external call, serialization). Use microsecond timers and asynchronous emit to local buffer. - For sampled full traces, capture full span stack and metadata. - For non-sampled requests, emit compact summaries: request id hash, start_ts, duration, top-k span durations (only spans > threshold), error flag.

3. Overhead limits: - In-process: limit instrumentation to a few critical spans; avoid allocations (use object pools) and async batching. - Network: batch metrics to local agent every 1s or when batch size threshold reached. - Target CPU <2% and additional tail latency <1ms (measure and tune).

4. Aggregation & storage: - Local agent aggregates histograms (HDR histograms) per endpoint/service per second; sends rolled-up histograms to central store (time-series DB) to reconstruct distribution without raw traces. - Full traces and tail-summaries go to trace store (bounded retention). Store compact summaries separately for heavy hitters.

5. Visualization & hotspot detection: - Use cumulative histograms (P50/P90/P95/P99/P999) and heatmaps by endpoint and time window. - Hotspot analysis: correlate compact span summaries and sampled full traces. For hotspots detected in aggregated histogram, surface top-k contributing spans by combining sampled traces and aggregated span-duration counters (e.g., cumulative span time per endpoint). - Show drill-down: distribution -> top contributing spans -> representative sampled traces.

Trade-offs & rationale:- Sampling + tail-capture balances observability vs cost: histograms give accurate distribution; full traces give debugging context.- Local summarization reduces network and storage load.- Adaptive tail capture ensures rare high-latency events are kept for root-cause analysis.

Implementation notes:- Use HDR histogram libs, a lightweight local agent (sidecar), and async non-blocking clients.- Continuously monitor profiling overhead and adjust sampling thresholds dynamically.

EasyTechnical

54 practiced

Write unit tests in Python using pytest for the following function signature: def normalize_username(s: str) -> str. The function should trim whitespace, lower-case the string, and replace consecutive internal spaces with a single underscore. Provide 5 test cases including edge, empty, and unicode inputs.

Sample Answer

Approach: normalize_username should strip leading/trailing whitespace, lowercase, and collapse any run of internal whitespace into a single underscore. Below is a compact implementation plus five pytest unit tests covering normal, multiple spaces, empty, all-space, and unicode/combining-whitespace cases.

python

# filename: test_normalize_username.py
import pytest
import re

def normalize_username(s: str) -> str:
    """
    Trim whitespace, lowercase, and replace consecutive internal whitespace with a single underscore.
    """
    if s is None:
        raise TypeError("s must be a string")
    # strip ends, lowercase
    trimmed = s.strip().lower()
    # replace any run of whitespace (including tabs/newlines) with single underscore
    normalized = re.sub(r'\s+', '_', trimmed)
    return normalized

def test_simple_trim_and_lowercase():
    assert normalize_username("  Alice ") == "alice"

def test_consecutive_spaces_to_single_underscore():
    assert normalize_username("John   Doe  Jr") == "john_doe_jr"

def test_empty_string_remains_empty():
    assert normalize_username("") == ""

def test_all_whitespace_becomes_empty_string():
    # spaces only -> strip -> empty -> nothing to replace -> empty
    assert normalize_username("   \t\n  ") == ""

def test_unicode_and_nonbreaking_spaces():
    # includes non-breaking space (\u00A0) and normal spaces; they should be treated as whitespace
    s = "Éléna\u00A0 \tSmith  "
    assert normalize_username(s) == "éléna_smith"

Key points:- Uses regex \s+ to cover spaces, tabs, newlines, and other Unicode whitespace.- Handles empty and all-whitespace inputs.- Raises TypeError for None (explicit guard).Complexity: O(n) time and O(n) space (regex allocates new string).

EasyTechnical

67 practiced

Given a function that sometimes throws an exception deep in a library, explain how you would instrument the codebase to get a stack trace and contextual variables without changing the library code. Describe approaches for Python, Java, or Node.js environments.

Sample Answer

Goal: capture a stack trace plus useful contextual variables when an exception originates deep inside a third‑party library — without editing that library. Approaches differ per runtime; use wrappers, runtime hooks, or external instrumentation.

Python- Strategy: wrap calls and capture exception info; use traceback + inspect to walk frames and read locals; use faulthandler for crashes; use sys.settrace or pdb post-mortem for live inspection.- Example:

python

import traceback, inspect, sys

try:
    library.do_work()
except Exception:
    tb = sys.exc_info()[2]
    for frame, lineno in traceback.walk_tb(tb):
        print(frame.f_code.co_name, frame.f_lineno)
        print(frame.f_locals)  # contextual variables
    raise

- Trade-offs: reading frame.f_locals works but can impact GC/perf; sys.settrace offers richer context but high overhead.

Java- Strategy: use a global uncaught-exception handler for threads, or attach a javaagent (ByteBuddy/ASM) to instrument methods at load time to capture locals and create richer error reports; use JVM tooling (jstack, jmap) or BTrace for live probes without code change.- Example (uncaught handler):

java

Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
    e.printStackTrace(); // stack trace
    // attach contextual info from your app (request id, user id) stored in ThreadLocal
    System.err.println("RequestId: " + RequestContext.getId());
});

- Trade-offs: bytecode agents can capture method args/locals but require more setup; handlers only expose what you can access (ThreadLocal/app context).

Node.js- Strategy: wrap async entry points, use process.on('uncaughtException') / unhandledRejection for last-resort traces; use the V8 Inspector / Debugger Protocol to capture scope locals programmatically or use APMs (Elastic/AWS/NewRelic).- Example:

javascript

process.on('uncaughtException', (err) => {
  console.error(err.stack);
  console.error('Context:', global.requestContext); // capture context you maintain
  process.exit(1);
});

- Trade-offs: V8 doesn't expose locals from stack traces easily without debugging APIs; best practice is to propagate context (e.g., async_hooks or CLS) so you can log it when exceptions occur.

General best practices- Maintain and propagate contextual metadata (request id, user id) in ThreadLocal/Context/async_hooks so any top-level handler can log it.- Prefer lightweight try/catch at boundary layers where you control code.- For production, consider bytecode/agent instrumentation or APMs to capture deeper info without changing library code, mindful of performance and security.

MediumTechnical

95 practiced

Describe an approach to measure the real-world impact of changing a sorting algorithm used in a user-facing list UI from O(n log n) to a specialized O(n) algorithm for typical inputs. Include A/B testing, telemetry, and fallbacks if the specialized algorithm fails for some inputs.

Sample Answer

Approach framework:1) Goal & success metrics- Primary: end-to-end UI list sort latency (median & 95th), frame drops/JS main-thread blocking, time-to-interactive for list, perceived latency (from RUM: time-to-first-sort-render).- Secondary: user engagement (clicks on sorted items, scroll depth), error rate, CPU/memory, fallback frequency.

2) Safety & constraints- Detect inputs where O(n) specialized algorithm may degrade (e.g., worst-case patterns, memory spikes). Define feature flags and runtime guards.

3) A/B test design- Randomize users (or sessions) into Control (existing O(n log n)) and Treatment (specialized O(n)). Stratify by device class, list size, network/CPU profile.- Sample size / duration: compute power for detecting a 10–20% reduction in median sort latency and 5% change in engagement; run at least 1–2 weeks to cover variability.

4) Instrumentation & telemetry- Client-side RUM events: sort_start, sort_end, items_count, algorithm_used, fallback_triggered, memory_used, CPU_hint, sort_exception.- Collect distributions (p50/p95), counts, and correlate with device metadata.- Server-side logs for feature-flag assignment and cohort.

5) Rollout & fallbacks- Canary deploy to small percentage; monitor telemetry dashboards and alerting on regressions (p95 latency up, error rate increased).- Runtime guard: if input size > threshold or detected adversarial pattern, switch to baseline algorithm. If specialized algorithm throws error or exceeds time budget, abort and use synchronous fallback with safe bounds.- Provide client-side configurable time budget (e.g., if sort takes >100ms, revert and record fallback).

6) Analysis & decision criteria- Use uplift analysis: compare latency distributions and engagement metrics with statistical tests (bootstrap CIs, A/A checks). Require no significant negative impact on p95 latency or error rate; require at least X% improvement in median latency or engagement improvement.- Segment analysis: ensure no regressions on low-end devices or large lists.

7) Implementation notes- Ensure deterministic unit tests & fuzz tests covering worst-case inputs.- Add synthetic benchmarks and CI performance tests.- Feature flag allowing instant rollback.

Example telemetry payload (JSON):{"event":"sort_complete","algo":"specialized","duration_ms":34,"p95_window_ms":120,"items":120,"fallback":false,"device":"low-end"}

Outcome expectation:- If treatment reduces median latency substantially without increasing p95/errors and shows neutral-or-positive engagement, roll to 100% with staged ramps. If regressions appear in segments, refine algorithm or tighten guard thresholds before wider rollout.

Unlock Full Question Bank

Get access to hundreds of Debugging, Testing, and Optimization interview questions and detailed answers.

Join thousands of developers preparing for their dream job.