Skip to main content
Back to DevDose Hub
āš”High-Yield CS Questions & Deep Dives

100 Days of Interview Questions

High-yield Computer Science, Operating Systems, System Design, and Concurrency questions explained intuitively with visual notes and code.

#01Why Isn't a 2-Way Handshake Enough in TCP?
Computer Networksā†’
#02Why Do Database Indexes Slow Down INSERTs?
Databasesā†’
#03Why Do Databases Use B+ Trees Instead of Binary Search Trees?
Databasesā†’
#04Why Is a Process Switch Slower Than a Thread Switch?
Operating Systemsā†’
#05Why Does Virtual Memory Make Computers Faster?
Operating Systemsā†’
#06Why Do Page Faults Happen?
Operating Systemsā†’
#07Why Do Zombie Processes Exist?
Operating Systemsā†’
#08Why is TCP Reliable but UDP Isn't?
Computer Networksā†’
#09Why Can't One Process Access Another's Memory?
Operating Systemsā†’
#10Why Does TCP Use a Sliding Window?
Computer Networksā†’
#11Why Do Databases Use Write-Ahead Logging (WAL)?
Databasesā†’
#12Why is HTTPS More Secure Than HTTP?
Computer Networksā†’
#13Why Do Deadlocks Happen?
Operating Systemsā†’
#14Why is UDP Used for Video Calls Instead of TCP?
Computer Networksā†’
#15Why Does Linux Use Copy-on-Write (COW)?
Operating Systemsā†’
#16Why Do Systems Use Rate Limiters?
System Designā†’
#17Why Prefer Composition Over Inheritance?
OOP & Designā†’
#18How Databases Handle Connection Spikes
Databasesā†’
#19Why Distributed Systems Use Consistent Hashing
System Designā†’
#20How Message Queues Handle Traffic Spikes
System Designā†’
#21Why DNS is Super Fast the Second Time
Computer Networksā†’
#22Why LIKE '%term' Destroys Database Performance
Databasesā†’
#23Why Production Systems Separate Reads & Writes
System Designā†’
#24Mutex vs. Spinlock: Why Sleeping Kills Performance
Operating Systemsā†’
#25Why ChatGPT Uses SSE Instead of WebSockets
System Designā†’
#26Why Priority Queues Use Heaps Instead of Arrays
Data Structures & Algorithmsā†’
#27Why Docker Boots in Milliseconds While VMs Take Minutes
Operating Systemsā†’
#28Why QuickSort beats MergeSort (O(NĀ²) vs O(N log N))!
Data Structures & Algorithmsā†’
#29Why NoSQL Sacrifices ACID for High Availability
System Designā†’
#30Forward Proxy vs Reverse Proxy: The Only Rule You Need
System Designā†’
#31Why APIs Use Idempotency Keys (Prevent Double Payments)
System Designā†’
#32Why Epoll is 100x Faster Than Select (I/O Multiplexing)
Operating Systemsā†’
#33Why Dynamic Arrays Double Their Size (ArrayList / std::vector)
Data Structures & Algorithmsā†’
#34Why Stack Memory is 10x FASTER Than Heap
Operating Systemsā†’
#35Why TRUNCATE is 100x Faster Than DELETE
Databasesā†’
#36Why Static Functions Cannot Access this in C++
OOP & Languagesā†’
#37Why Array Traversal is 10x FASTER Than Linked Lists
Data Structures & Algorithmsā†’
#38Why Low-Priority Threads FREEZE High-Priority Tasks
Operating Systemsā†’
#39Why NULL = NULL is FALSE in SQL
Databasesā†’
#40Why Strings are IMMUTABLE (Python, JS, Java)
OOP & Languagesā†’
#41Why malloc(1GB) DOES NOT Consume 1GB RAM
Operating Systemsā†’
#42Why Expired Cache Keys CRASH Databases
System Designā†’
#43Non-Repeatable Read vs Phantom Read
Databasesā†’
#44How Bloom Filters Actually Work
System Designā†’
#45Why Base Destructors MUST Be Virtual in C++
OOP & Languagesā†’
#46Why Running Out of RAM Freezes Your CPU (Thrashing)
Operating Systemsā†’
#47Why Sorted Arrays Run 6x FASTER (Branch Prediction)
Data Structures & Algorithmsā†’
#48College vs Production: Database Normalization (3NF vs Denormalization)
Databasesā†’
#49College vs Production: Database Locking & MVCC
Databasesā†’
#50College vs Production: Why Recursion CRASHES in Production
Data Structures & Algorithmsā†’
#51College vs Production: Why SHA-256 Fails for Passwords
System Designā†’
#52Search Autocomplete: Debounce vs Throttle
System Designā†’
#53How to Scale WebSockets Across Multiple Servers
System Designā†’
#54Why Random UUIDs SLOW DOWN Your Database
Databasesā†’
#55Why HashMap Capacity is ALWAYS a Power of 2
Data Structures & Algorithmsā†’
#56Why 32-Bit Systems CANNOT Use 8GB RAM
Operating Systemsā†’
#57Why 0.1 + 0.2 ā‰  0.3 in Programming
OOP & Languagesā†’
#58Why 2GB Free RAM CAN'T Allocate 200MB (External Fragmentation)
Operating Systemsā†’
#59Why 1 + 4 + 1 = 12 Bytes in C/C++ (Struct Padding)
OOP & Languagesā†’
#60How SYN Cookies STOP Server Crashes
Computer Networksā†’
#61Why User Apps CANNOT Touch Hardware (CPU Protection Rings)
Operating Systemsā†’
#62Why Sending 1 Reads as 16,777,216 Over Sockets (Endianness)
Computer Networksā†’
#63Why CPUs Reorder Code Behind Your Back (Memory Barriers)
Operating Systemsā†’
#64Why HashMaps Switch to Trees at 8 Collisions
Data Structures & Algorithmsā†’
#65Why WHERE age + 1 > 30 Kills Your Database Index
Databasesā†’
#66How Flash Sales Accidentally Sell 2 Items When Stock is 1
Databasesā†’
#67Why You CANNOT Truly Invalidate a JWT
System Designā†’
#68Why You Should NEVER Deploy 4 Nodes in a Cluster (Split-Brain & Quorum)
System Designā†’
#69Why 8-Core CPUs FAIL With 8 Threads (False Sharing & Cache Contention)
Operating Systemsā†’
#70Why Postman Works But Browsers Block Your API (CORS)
Computer Networksā†’
#71Why Fast Pointer Moves at EXACTLY 2x (Floyd's Cycle Finding)
Data Structures & Algorithmsā†’
#72The Bug That Broke Java for 9 Years (Binary Search Overflow)
Data Structures & Algorithmsā†’
#73Why HashSet Can't Find Your Object (Mutable Keys)
Data Structures & Algorithmsā†’
#74Why String += in Loops Kills Your Code (O(NĀ²) Copy Trap)
OOP & Languagesā†’
#75Why Google NEVER Sends Tokens to Your Browser (OAuth 2.0 PKCE & BFF)
System Designā†’
#76Why kill -9 CANNOT Kill a Zombie Process
Operating Systemsā†’
#77Why free() NEVER Returns RAM to Your OS (Heap Top-of-Heap & Arenas)
Operating Systemsā†’
#78Why Fast APIs Crash with 'Cannot Assign Address' (TIME_WAIT)
Computer Networksā†’
#79Why Math.abs() Returns a NEGATIVE Number
OOP & Languagesā†’
#80Why Multi-Threaded fork() Freezes Your Code (Deadlocks)
Operating Systemsā†’
#81How Kafka Streams at 0% CPU (Linux Zero-Copy sendfile)
System Designā†’
#82How Redis Counts 1 Billion Users in 12 KB RAM (HyperLogLog)
System Designā†’
#83Why Large Systems Prefer Rendezvous Hashing (HRW)
System Designā†’
#84Why Optimistic Concurrency Control Beats Locks (OCC)
Databasesā†’
#85Why Python Leaks Memory (Garbage Collection Explained)
OOP & Languagesā†’
#86Why 100 is 100 is True, but 300 is 300 is False in Python
OOP & Languagesā†’
#87Why & Crashes Your Code While && Runs Safely (Short-Circuit Evaluation)
OOP & Languagesā†’
#88Why OFFSET Kills Database Performance (Deep Pagination)
Databasesā†’
#89The N+1 Query Problem Explained
Databasesā†’
#90Why UDP Needs Ports Without Connections (Multiplexing)
Computer Networksā†’
šŸš€ Level Up Your Engineering Mindset

Never Study in Isolation. Join Binary Dose.

Connect with fellow engineers, clear conceptual doubts, and get 2 visual breakdowns & engineering mental models daily across our community channels.

Discord
Official Hub

Discord Community

Start at #welcome-and-rules, say hello in #general-chat, clear doubts, and collaborate with engineers worldwide.

Join Discord Serverā†’
āš”
Daily Knowledge Drops

Daily Visual Deep-Dives

Bite-sized system design schematics, core OS internals, and DSA intuition served right into your feeds every single day.

TelegramTelegramLinkedInLinkedInXX (Twitter)InstagramInstagramYouTubeYouTubeThreadsThreadsDev.toDev.to
šŸ’”Have handwritten notes, cheat-sheets, or want to publish a technical article?
Learn How to Contributeā†’