Skip to main content

Planner Learn Utilities Arcade

Theme

Loading page...

Explore Courses Dashboard Questions Recall Quest Quiz Code lab

Workspace

Dashboard Search Recall Quest Topic quiz Code lab

Subjects

10

Java & Spring Boot

1.Java Memory Model Foundations: Visibility, Ordering, and Safe Publication
2.ConcurrentHashMap Internals: Coordinating Updates Without One Global Lock
3.Spring Transaction Boundaries: Where to Commit and When to Split
4.JVM Memory Errors: Diagnose Heap Exhaustion, StackOverflow, and Leaks
5.Java Thread Dumps: Find Deadlocks, Starvation, and Lock Contention
6.Java equals and hashCode: Fix Broken HashMap and HashSet Lookups
7.Java Exception Debugging: Trace the Root Cause and Fix the Boundary
8.Advanced Java and Spring: Runtime, Concurrency, Proxies, and Reactive Failure Modes
9.Java Appointment Times: Resolve DST Gaps and Overlaps Explicitly
10.Java deadlines: spend one budget across every stage
11.Java class-loader retention: why an undeployed app can remain in memory

Python & Async APIs

1.Python Data Model Foundations: Objects, Types, and Reliable Boundaries
2.Python Collections: Lists, Tuples, Sets, and Map/Reduce Trade-offs
3.Python Error Debugging: Tracebacks, Root Causes, and Safe Fixes
4.FastAPI Async Patterns: When to Use Background Tasks vs Real Concurrency
5.FastAPI Backpressure: Protecting Your Service from Unbounded Fan-Out
6.Async Python Cancellation and Timeouts: Stop Work Without Leaking It
7.Debugging Flaky Python Tests: Time, State, Concurrency, and Isolation
8.Python Async Runtime Advanced: GIL, ASGI Lifecycles, and Safe Concurrency
9.Python Runtime Advanced: Native Memory, ASGI Lifecycles, and Worker Failure
10.Python Event Times: Normalize Offsets Without Losing Elapsed Time
11.Python queues: bound waiting work and own its completion
12.Python TaskGroups: make sibling failure and cleanup part of the design

Security & Authentication

1.Authentication Foundations: Sessions, Cookies, and Trust Boundaries
2.Security Boundaries: Object Authorization, Input Validation, and Secret Handling
3.Tenant authorization: carry trusted scope into every lookup
4.CSRF defenses: reason from browser credential attachment, not CORS

Distributed Systems

1.Distributed Systems Foundations: Consistency, Retries, and Delivery Semantics
2.Kafka Consumer Groups: Architecture & Common Pitfalls
3.Idempotency and the Transactional Outbox: Making Retries Safe
4.Distributed Systems Advanced: Rebalancing, Sagas, Consensus, and Trace Context
5.Consensus and Observability Advanced: Quorums, Split Brain, and Trace Context
6.Event-Time Windows: Watermarks, Late Data, and Correctable Results
7.Fencing tokens: reject workers whose lease has expired
8.Causal order: what a logical clock can and cannot tell you

DevOps & Delivery

1.DevOps Foundations: Reproducible Builds and Artifact Promotion
2.DevOps Foundations: Safe Changes, Health Signals, and Rollback Boundaries
3.Docker Multi-Stage Builds: Optimization Patterns for Production
4.Production Observability: Signals, Service Objectives, and Useful Alerts
5.Reliable CI Pipelines: Fast Feedback Without Hiding Failures
6.Delivery Engineering Advanced: Build Caches, Runner Isolation, and Safe Releases
7.Release Safety Advanced: State, Schema Compatibility, and Artifact Trust
8.Incident Timelines: Separate Event Time, Receipt Time, and Clock Evidence
9.Scheduled jobs: separate a logical run from its attempts
10.CI workload identity: replace copied cloud keys with scoped claims

Databases & SQL

1.Relational Databases and SQL Foundations: Model the Invariant First
2.PostgreSQL MVCC and Indexes: Reads, Vacuum, and Query Plans
3.MySQL InnoDB: Transactions, Indexes, and Reading EXPLAIN
4.Oracle SQL: Analytic Functions, Execution Plans, and Bind Variables
5.SQL Query Recipes: Joins, Grouping, Window Functions, and Safe Pagination
6.Top-N and Third-Highest Salary Queries in PostgreSQL, MySQL, and Oracle
7.Stored Functions, Procedures, and Triggers: Put Logic in the Right Layer
8.Database Locks and Isolation: Diagnose Blocking, Deadlocks, and Retries
9.Fix Slow SQL: N+1 Queries, Missing Indexes, and Bad Cardinality Estimates
10.Database Internals Advanced: MVCC Anomalies, Cost Models, Sharding, and Storage Engines
11.SQL Event Gaps: LAG, Stable Ordering, and Explicit Window Frames
12.SQL keyset pagination: continue an order without promising a snapshot
13.PostgreSQL concurrent indexes: reason about locks, retries, and invalid states

Unix & Linux

1.Unix Foundations: File Permissions, Ownership, and Descriptors
2.grep, sed, and awk: Reliable Text Search and Small Stream Programs
3.Shell Script Debugging: Trace Failures, Preserve Exit Codes, and Fix Safely
4.TCP, UDP, ss, netstat, and tcpdump: A Layered Network Debugging Guide
5.pipefail, Signals, and Unix Process Management
6.Unix Signals and Child Processes: What Your Service Must Clean Up
7.DNS Troubleshooting: Trace Name Resolution Before Blaming the Network
8.Linux Disk Full Errors: Blocks, Inodes, Deleted Files, and Safe Cleanup
9.Linux Under Load: Epoll, File Descriptors, OOM, TCP Queues, and VFS
10.Unix Log Sorting: Normalize Offset Timestamps Before Ordering Events
11.Unix file publication: replace names without exposing partial bytes
12.Unix process inheritance: environment variables and file descriptors

HTTP & APIs

1.HTTP Foundations: Methods, Status Codes, and Representation Boundaries
2.Reliable API Clients: Pagination, Conditional Requests, and Retry Budgets
3.HTTP conditional writes: detect an edit based on stale state
4.HTTP range requests: resume transfers without stitching different files

Kubernetes & Platform

1.Kubernetes Foundations: Pods, Workloads, and Declarative State
2.Kubernetes Foundations: Services, Configuration, and Least-Privilege Access
3.Kubernetes Foundations: Objects, Controllers, and Reconciliation
4.Kubernetes Rollouts: Readiness, Health Checks, and Safe Deployments
5.Kubernetes Requests, Limits, and Autoscaling: A Practical Capacity Model
6.Kubernetes Advanced Operations: Packet Paths, Rollouts, DNS, and Operators
7.Kubernetes CronJobs: Timezones, Missed Starts, and Duplicate Work
8.Kubernetes disruption budgets: protect capacity, not every failure
9.Kubernetes finalizers: deletion is a protocol, not a cleanup callback

TypeScript & Node.js

1.TypeScript Foundations: Narrow Unknown Data Before Trusting It
2.Node.js Foundations: Event Loop Work, Backpressure, and Cancellation
3.TypeScript results: distinguish absence, invalid input, and dependency failure
4.TypeScript async iterators: connect pull-based demand to resource cleanup

Learn / Java & Spring Boot quiz

Java & Spring Boot quiz

A focused round on this track. Submit to see your score and explanations, then return to another subject whenever you like.

Choose another subject

Question 1

Java1 / 10

Which reference can prevent an old application class loader from being collected?

An unreachable cycle among its own classesA parent-loaded registry holding an application objectA completed deployment record with no referencesA class name stored only in a log file

Question 2

Java2 / 10

A 200 ms request has already spent 150 ms. What should the next stage receive?

A fresh 200 ms timeoutAt most the remaining 50 msA nanoTime value from another JVMAn unlimited timeout after rounding to zero

Question 3

Java3 / 10

What primarily causes a Java HashMap to resize?

A bucket becomes emptyThe number of entries crosses the capacity and load-factor thresholdA key is removedThe map detects multiple threads

Question 4

Java4 / 10

Which statement best describes modern ConcurrentHashMap updates?

Every operation locks the entire mapIt uses only the old fixed segment locksIt combines CAS paths with coordination at individual bins when neededIt makes mutable values thread-safe automatically

Question 5

Java5 / 10

Which symptom most strongly points to runaway recursion rather than Java heap exhaustion?

StackOverflowError with repeating framesOutOfMemoryError: Java heap spaceA growing post-GC heap live setDirect buffer memory exhaustion

Question 6

Java6 / 10

What is the most direct evidence of a monitor deadlock in a Java thread dump?

One thread is RUNNABLEA cycle of threads waiting for locks held by each otherA high heap occupancy after GCA large executor queue by itself

Question 7

Java7 / 10

Why should ThreadLocal state be cleared when using pooled threads?

Pools never reuse worker threadsA later task may inherit retained state from an earlier taskThreadLocal always copies values to every threadIt prevents garbage collection of the JVM

Question 8

Java8 / 10

What contract must a Java type respect when used as a HashMap key?

Equal objects must have equal hash codes, and key state remains stable while storedEvery unequal object must have a globally unique hashhashCode must never use fieldsequals may return different answers on repeated calls

Question 9

Java9 / 10

When a framework exception wraps another Java failure, what should you inspect first?

Only the top exception classThe complete cause chain and deepest relevant application frameThe newest unrelated log messageThe heap maximum alone

Question 10

Java10 / 10

Thread A writes payload, then sets volatile ready=true. Thread B reads ready=true, then reads payload. What does the volatile edge guarantee?

B sees writes before A’s volatile write; a separate monitor only adds ordering if both threads use the same monitorEvery field in the process becomes globally synchronized foreverThe volatile field makes all later compound operations atomicThe synchronized block is irrelevant even if both threads share its monitor

Answer all 10 questions to see your score.