Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
878 drills fit a 10-minute session. Closest fits first.
Page 33 of 37
Explains how delegation preserves replaceable behavior and narrower coupling while recognizing valid inheritance cases.
Explains Java generic invariance through the unsafe write that subtype assignment would otherwise permit.
Separates String immutability from interning and connects both to safe sharing, equality, concatenation, and practical performance.
Connects Java's equality and hash contracts to real HashMap and HashSet behavior, including mutable-key failures.
Explains Java lambda capture through copied local values, mutable referenced objects, lifetime, and safe state handling.
Uses hierarchy and adjacency to recover context that flat chunks lose while avoiding indiscriminate document expansion.
Explains local filesystem limits, multiple instances, in-memory state, distributed cache, durable storage, and scale-out-safe API design.
Explains how generated text, markup, code, URLs, and tool arguments can become injection or integrity risks downstream.
Keeps JSON binding, validation, writable fields, and response evolution separate from domain and persistence models.
Explains how to choose an E2E flow, control test data, avoid brittleness, and cover frontend/API integration risk.
Chooses counters, traces, stack snapshots, GC dumps, full dumps, or a profiler from the production symptom and investigation cost.
Explains Aspire as a code-first application model and developer experience without confusing it with a production runtime or architecture style.
Separates hiding implementation complexity from controlling access to state, with practical examples where both ideas work together.
Uses public, internal, protected, private, and protected internal deliberately to control API surface and inheritance exposure.
Explains attribute routing, binding-source inference, automatic validation responses, and where explicit domain validation still belongs.
Clarify the common misconception that await starts work on a new thread, and explain what actually happens for I/O-bound operations.
Separates identity establishment from permission decisions and applies ASP.NET Core schemes, policies, tenant boundaries, ownership checks, and correct challenge or forbid behavior.
Explains how TTL choices balance freshness, load reduction, user expectations, and operational safety.
Chooses a sequential collection from size, mutation, access pattern, memory locality, and the behavior callers actually need.
Explains how unit, integration, contract, component, and end-to-end tests cover different failure boundaries.
Explains the difference between a class and an object, then connects type definitions, instances, identity, and shared behavior to practical C# code.
Explains when local process memory is enough and when shared Redis-style caching is worth the extra dependency.
Compares point-to-point queues with publish-subscribe topics and explains when each model fits.
Explains process isolation, shared kernels, image-based deployment, and where containers differ operationally from virtual machines.