Loading
Pick a focused question that fits your time, stack, and interview goal.
300 results across 1 active filter
Page 1 of 13
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.
Separates application composition in AppHost from reusable in-process defaults for telemetry, health, resilience, and service discovery.
Separates container instance reuse from concurrency guarantees and designs singleton services around stateless or safely coordinated state.
Shows how task interleaving across await points can violate a multi-step invariant.
Chooses contracts and shared implementation based on substitutability, state ownership, evolution, and inheritance constraints.
Chooses a type shape from identity, value semantics, mutation, copy cost, default values, and serialization boundaries.
Creates valid objects with clear intent while choosing construction patterns proportionally to optional data, validation, and lifecycle complexity.
Selects small structural and behavioral patterns from the problem being solved instead of pattern-name recognition.
Explains the difference between a class and an object, then connects type definitions, instances, identity, and shared behavior to practical C# code.
Explains inward dependency flow, stable business policy, adapters, and when a smaller project structure is enough.
Combines focused collaborators for independent behavior while recognizing cases where a genuine stable hierarchy remains simpler.
Applies CQRS proportionally, separating model responsibilities without assuming separate databases, messaging, or event sourcing.
Distinguishes instants, local calendar values, offsets, and named time zones so APIs and persistence survive daylight-saving and locale boundaries.
Distinguishes explicit dependency injection from runtime service lookup and identifies the narrow framework boundaries where scoped resolution is legitimate.
Keeps business policy independent from infrastructure while centralizing concrete dependency assembly at the application edge.
Clarifies Django's object-permission hook and enforces ownership or tenancy in the query and policy path.
Uses controlled state transitions and intention-revealing APIs to keep objects valid rather than treating encapsulation as private fields alone.
Turns a modular-monolith choice into enforceable code and data ownership rather than relying on folders and team discipline alone.
Connects equality semantics to hash-based collections and chooses identity or value equality deliberately.
Improves architecture through protected behavior, incremental boundaries, and measurable delivery instead of a risky all-at-once rewrite.
Finds failures hidden by test-owned transactions, automatic rollback, open persistence contexts, missing flushes, and separate server threads.
Separates caller time bounds, cancellation propagation, and ownership of protected underlying work.
Separates authentication orchestration, mechanism-specific verification, and username-based user lookup.