OS
OpenStem
@openstem · Joined Jul 2026
7420 public items8 groups
Flashcards10 cards
What is the difference between a taint (on a node) and a toleration (on a Pod)?1 / 10
A taint repels Pods from a node unless the Pod has a matching toleration. Taints/tolerations work together to keep Pods OFF nodes (e.g. dedicated GPU nodes); they do not, by themselves, attract Pods — that's node affinity's job.
K8s Scheduling, Operators & CRDs
@openstem
K8s Scheduling, Operators & CRDsFlashcards10 cards
What is the core idea of a service mesh?1 / 10
A service mesh moves cross-cutting networking concerns (mTLS, retries, timeouts, traffic shifting, telemetry) out of application code into a sidecar proxy (data plane) per Pod, controlled by a central control plane. Apps stay oblivious to the L7 logic.
Service Mesh & GitOps
@openstem
Service Mesh & GitOpsFlashcards10 cards
Why does the 'testing trophy' reweight the pyramid toward integration tests, and what assumption changes?1 / 10
The pyramid assumes unit tests are the cheapest path to confidence; the trophy assumes wiring and boundary bugs dominate, so integration tests (real collaborators, mocked edges) buy the most confidence-per-cost. It widens the middle layer and adds static analysis/types as the base, treating heavily-mocked unit tests as low-value.
Test Architecture & Test Doubles
@openstem
Test Architecture & Test DoublesFlashcards10 cards
What are the main root-cause categories of flaky tests?1 / 10
Uncontrolled time (wall-clock, timezones, sleeps), randomness (unseeded RNG, random ordering), concurrency and test-ordering dependencies, network/external services, and shared mutable state (files, DB rows, global singletons) leaking between tests. Each introduces a non-deterministic input the assertion silently depends on.
Determinism, Flakiness & CI Scale
@openstem
Determinism, Flakiness & CI ScaleFlashcards10 cards
What is 'speculative generality' and why is it a design smell?1 / 10
Adding abstraction, hooks, or parameters for hypothetical future needs that never arrive. It pays complexity cost up front against an uncertain payoff; YAGNI argues you should add flexibility only when a concrete second case forces it, since unused indirection is harder to read and to remove.
Anti-Patterns & Pattern Trade-offs
@openstem
Anti-Patterns & Pattern Trade-offsFlashcards10 cards
In Hexagonal Architecture (Ports & Adapters), what is the rule about dependency direction?1 / 10
The domain core defines ports (interfaces) and never depends on infrastructure; adapters (DB, HTTP, queues) depend inward on those ports. All dependencies point toward the domain, so persistence and transport are pluggable and the core is testable without them.
Architectural & Concurrency Patterns
@openstem
Architectural & Concurrency PatternsFlashcards10 cards
Walk through the singleton bean creation lifecycle in order.1 / 10
Instantiate (constructor) → populate properties (dependency injection) → call *Aware interfaces (BeanNameAware, BeanFactoryAware, ApplicationContextAware) → BeanPostProcessor.postProcessBeforeInitialization → init callbacks (@PostConstruct, then InitializingBean.afterPropertiesSet, then a custom init-method) → BeanPostProcessor.postProcessAfterInitialization → bean is ready. On shutdown: @PreDestroy, then DisposableBean.destroy, then a custom destroy-method.
IoC Container, Bean Lifecycle & AOP
@openstem
IoC Container, Bean Lifecycle & AOPFlashcards10 cards
Contrast the REQUIRED, REQUIRES_NEW, and NESTED transaction propagation modes.1 / 10
REQUIRED (default) joins the caller's transaction or starts one if none exists. REQUIRES_NEW always suspends any existing transaction and runs in an independent new one that commits/rolls back on its own — useful for audit logs that must persist even if the outer call rolls back. NESTED runs inside the current transaction at a JDBC savepoint, so it can roll back to that savepoint without aborting the outer transaction (requires savepoint support, e.g. the DataSourceTransactionManager on JDBC).
Transactions, Persistence & Reactive
@openstem
Transactions, Persistence & ReactiveFlashcards10 cards
Precisely how does an isolate's event loop interleave the microtask and event queues?1 / 10
After each event-queue item completes, the loop drains the entire microtask queue — including microtasks scheduled while draining — before pulling the next event-queue item. Microtasks added during a microtask thus run before any timer or I/O event, so a runaway microtask producer can starve the event queue indefinitely.
Dart VM, Isolates & Async Internals
@openstem
Dart VM, Isolates & Async InternalsFlashcards10 cards
What makes Dart's null safety *sound*, and what runtime cost does that soundness avoid?1 / 10
Soundness means a non-nullable static type provably never holds null at runtime, so the compiler can omit null checks the type guarantees away — enabling smaller, faster code and unboxed representations. It is enforced end-to-end: there is no `dynamic`-style escape hatch that silently introduces null into a non-nullable type without a checked cast or `!`.
Type System, Null Safety & Compilation
@openstem
Type System, Null Safety & CompilationFlashcards10 cards
What is each of the three trees responsible for, and how do they relate?1 / 10
The Widget tree is an immutable, cheap-to-rebuild configuration. The Element tree is the long-lived, mutable instantiation that holds state, BuildContext, and parent/child links. The RenderObject tree does layout, painting, and hit testing. Each Element points to one widget (its current config) and, for RenderObjectElements, to one RenderObject.
Rendering Pipeline: Widget / Element / RenderObject
@openstem
Rendering Pipeline: Widget / Element / RenderObjectFlashcards10 cards
What does a RepaintBoundary do at the layer level, and when does it actually help?1 / 10
It inserts its own `OffsetLayer` so its subtree is rasterized into a separate retained layer; a repaint inside it does not dirty siblings, and a sibling's repaint does not dirty it. It helps when a small region animates frequently (e.g. a progress spinner) so the static rest of the screen is not re-recorded each frame — but adding boundaries everywhere wastes memory and composite time.
Performance, Slivers & Custom Rendering
@openstem
Performance, Slivers & Custom RenderingFlashcards10 cards
What is the RSC payload, and how does it differ from the HTML a route produces?1 / 10
The RSC payload is a compact serialized description of the Server Component tree — rendered element output plus placeholders for Client Components and their props. The server uses it to produce the initial HTML, then streams the same payload to the client so React can reconcile and hydrate the Client Component holes without re-running server logic.
Rendering Architecture: RSC, Streaming & Caching
@openstem
Rendering Architecture: RSC, Streaming & CachingFlashcards10 cards
What runs in Next.js middleware, and why does its placement matter?1 / 10
Middleware executes before the matched route resolves, on every request that passes its `matcher`, letting you rewrite, redirect, or set headers/cookies (e.g. auth gating, locale routing). Because it runs on the critical path for matched requests, the work must be cheap — heavy logic or per-request data fetches there add latency to everything behind it.
Routing, Middleware & Edge Runtime
@openstem
Routing, Middleware & Edge RuntimeFlashcards10 cards
What are the three provider scopes, and what does each cost at runtime?1 / 10
`Scope.DEFAULT` (singleton) instantiates once and is shared. `Scope.REQUEST` creates a fresh instance per incoming request, so the whole injection chain above it also becomes request-scoped — adding per-request allocation and a `ContextId` lookup. `Scope.TRANSIENT` gives each consumer its own dedicated instance. Request/transient scope sacrifice the singleton fast path, so reserve them for genuinely per-request or per-consumer state.
DI Container, Modules & Execution Context
@openstem
DI Container, Modules & Execution ContextFlashcards10 cards
Recite the exact order of the request pipeline, including where exception filters sit.1 / 10
Middleware → guards → interceptors (before `next.handle()`) → pipes → route handler → interceptors (after, operating on the returned stream) → response. Exception filters wrap the whole flow: any error thrown in a guard, pipe, handler, or interceptor is routed to the matching filter. Pipes run after guards because authorization should fail fast, before spending work parsing/validating input.
Interceptors, Guards, Pipes & Microservices
@openstem
Interceptors, Guards, Pipes & MicroservicesFlashcards11 cards
What concurrency granularity does the WiredTiger storage engine provide?1 / 11
Document-level concurrency control: concurrent writes to different documents in the same collection don't block each other. WiredTiger uses optimistic concurrency, detecting write conflicts at commit; on a conflict MongoDB transparently retries the operation.
Storage Engine, Indexing & Query Internals
@openstem
Storage Engine, Indexing & Query InternalsFlashcards11 cards
How does a replica set election decide which member becomes primary?1 / 11
Members run a Raft-like protocol: a candidate requests votes and needs a strict majority of voting members to win. Only members whose oplog is current enough are eligible, and `priority`/`votes` settings influence eligibility — so a member with stale data cannot be elected.
Replication, Sharding & Consistency
@openstem
Replication, Sharding & ConsistencyFlashcards10 cards
What are xmin and xmax on a PostgreSQL heap tuple?1 / 10
Every heap row has system columns: `xmin` is the transaction ID that inserted it; `xmax` is the XID that deleted/updated it (0 = still live). MVCC uses these to determine which rows are visible to a snapshot.
Internals & MVCC
@openstem
Internals & MVCCFlashcards10 cards
What is the difference between streaming replication and logical replication in PostgreSQL?1 / 10
Streaming replication ships WAL bytes, producing a byte-for-byte copy of the primary (physical). Logical replication decodes WAL into row-change events and applies them, enabling selective table replication, cross-version, or cross-OS replication.
Replication & Scaling
@openstem
Replication & ScalingFlashcards10 cards
What are the pillars of the AWS Well-Architected Framework?1 / 10
The framework has six pillars: Operational Excellence, Security, Reliability, Performance Efficiency, Cost Optimization, and Sustainability.
Well-Architected & Resilience
@openstem
Well-Architected & ResilienceFlashcards10 cards
What does AWS Organizations provide?1 / 10
Organizations centrally manages multiple AWS accounts, enabling consolidated billing, organizational units (OUs), and Service Control Policies for governance at scale.
Multi-Account & Advanced Networking
@openstem
Multi-Account & Advanced NetworkingFlashcards10 cards
How do IAM allow policies combine down the organization → folder → project → resource hierarchy?1 / 10
Each node has its own allow policy, and a principal's effective access is the union of all bindings inherited from every ancestor plus the resource itself. Allow policies are purely additive — a child cannot revoke a role granted higher up; that requires an IAM deny policy or removing the binding at its source.
IAM, Resource Hierarchy & Security
@openstem
IAM, Resource Hierarchy & SecurityFlashcards10 cards
How do VPC global scope and regional subnets shape a multi-region design?1 / 10
A VPC network is global, so subnets (each tied to one region) share a single private routing domain and can talk over internal IPs without peering or VPNs. This lets you place workloads in multiple regions inside one VPC, but subnet CIDR ranges are regional resources and must be planned to avoid overlap, especially before peering with other VPCs.
Networking, Load Balancing & Reliability
@openstem
Networking, Load Balancing & ReliabilityFlashcards10 cards
What exactly does Terraform store in state, beyond a list of resources?1 / 10
A JSON document mapping each resource address to the provider's full attribute snapshot, plus dependency edges, the resource's provider, and a serial/lineage for change tracking. It's the source of truth Terraform diffs against to compute a plan — without it Terraform can't tell what it already manages.
State, Internals & Drift
@openstem
State, Internals & DriftFlashcards10 cards
What is the difference between composition and inheritance in module design?1 / 10
Terraform has no inheritance — a root module composes child modules by passing outputs of one as inputs to another. Favor small, single-purpose modules wired together over deep nesting, which makes the data flow explicit and keeps blast radius and reuse bounded.
Module Design, Providers & Scale
@openstem
Module Design, Providers & ScaleFlashcards9 cards
What is the fundamental trade-off between symmetric and asymmetric encryption?1 / 9
Symmetric ciphers (AES) are orders of magnitude faster and use one shared key, but distributing that key securely is hard. Asymmetric ciphers (RSA, ECC) solve key distribution with public/private key pairs but are far more computationally expensive. Real protocols (TLS) use asymmetric crypto only to exchange a symmetric session key, then switch to symmetric encryption for bulk data — a hybrid scheme.
Applied Cryptography for Engineers
@openstem
Applied Cryptography for EngineersFlashcards9 cards
What is the main weakness of range-based sharding?1 / 9
Range sharding (e.g. splitting by user ID range) preserves ordering and makes range queries efficient, but concentrates writes onto whichever shard owns the currently 'hot' range — e.g. all new signups land on the last shard if sharded by monotonically increasing ID, creating a hotspot.
Data Partitioning & Replication at Scale
@openstem
Data Partitioning & Replication at ScaleFlashcards9 cards
What is an error budget and what does it govern?1 / 9
The error budget is 1 minus the SLO (e.g. 99.9% SLO leaves a 0.1% budget) — the amount of unreliability the business tolerates over a window. It governs the release/risk tradeoff: while budget remains, teams can ship features and take risks; once it's exhausted, the org shifts focus to reliability work (freezing risky launches) until the budget recovers.
Site Reliability Engineering
@openstem
Site Reliability EngineeringFlashcards8 cards
What is the difference between leader-based (single-master) and leaderless replication?1 / 8
Leader-based replication routes all writes through one designated node, which propagates changes to followers — simple to reason about, but the leader is a bottleneck and failover requires electing a new one. Leaderless replication (e.g. Dynamo-style) lets any replica accept a write and relies on quorum reads/writes plus conflict resolution to stay consistent, trading simplicity for higher write availability.
Distributed Systems Engineering
@openstem
Distributed Systems Engineering