Loading
Pick a focused question that fits your time, stack, and interview goal.
32 results across 1 active filter
Page 1 of 2
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.
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 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.
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.
Chooses immutable values and controlled mutable entities based on identity, concurrency, invariants, allocation cost, and update semantics.
Uses inheritance only for stable behavioral subtyping and tests whether derived objects preserve the promises callers rely on.
Designs consumer-focused contracts that reduce accidental authority and coupling without producing meaningless one-method wrappers.
Explains substitutability through inputs, outputs, side effects, and failure behavior rather than inheritance syntax alone.
Starts object-oriented design from cohesive state and behavior instead of creating classes for every noun in a requirement.
Uses stable extension points for genuinely variable behavior while avoiding speculative abstractions and configuration-driven branching.
Separates compile-time overload selection from runtime virtual dispatch and diagnoses method hiding through a base reference.