OpenStem

@openstem · Joined Jul 2026

7420 public items8 groups

Note~507 words · 3 min

Schema-First Thinking A GraphQL API is defined by a strongly typed schema written in the Schema Definition Language (SDL): object types, scalars, enums, interfaces, and the three root operation types. The schema is a contract — clients can

Software

Software · L3 · GraphQL API Design

@openstem

Note~594 words · 3 min

Queues vs Pub/Sub A message queue distributes work: each message is delivered to exactly one consumer from a competing pool, so adding consumers increases throughput. A pub/sub topic broadcasts: every subscriber gets its own copy of each me

Software

Software · L3 · Message Queues & Event-Driven Communication

@openstem

Note~287 words · 1 min

Big-O complexity cheat sheet Big-O notation describes how an algorithm's running time or space grows with input size n, ignoring constant factors and lower-order terms. Common complexity classes (fastest → slowest) Binary search example Bin

Software

Software · L4 · Big-O complexity cheat sheet

@openstem

Note~382 words · 2 min

Designing a REST API REST (Representational State Transfer) models server-side resources as URLs and uses HTTP verbs to express actions on those resources. HTTP verbs and their semantics Idempotency An operation is idempotent if calling it

Software

Software · L4 · Designing a REST API

@openstem

Note~418 words · 2 min

SQL essentials SQL (Structured Query Language) is the standard language for relational databases. Understanding its core clauses and their execution order prevents common mistakes. Logical execution order JOIN types Indexes A B-tree index t

Software

Software · L4 · SQL essentials

@openstem

Note~439 words · 2 min

Concurrency patterns and pitfalls Concurrent programming allows multiple tasks to make progress simultaneously, but introduces hazards that single-threaded code never encounters. Core hazards Mutex (mutual exclusion lock) A mutex allows onl

Software

Software · L4 · Concurrency patterns and pitfalls

@openstem

Note~710 words · 4 min

Applied Cryptography for Engineers Most engineers never implement a cipher, but every engineer builds systems that depend on cryptographic primitives being composed correctly. The failures that matter in practice are almost never 'AES was b

Software

Software · L4 · Applied Cryptography for Engineers

@openstem

Note~737 words · 4 min

Data Partitioning & Replication at Scale A single machine eventually runs out of disk, memory, or write throughput. Partitioning (sharding) splits data across many machines so the system scales horizontally; replication copies data across m

Software

Software · L4 · Data Partitioning & Replication at Scale

@openstem

Note~678 words · 3 min

Site Reliability Engineering practice SRE treats operations as a software problem: reliability targets are explicit, the tradeoff between velocity and stability is quantified, and incident response is a practiced discipline rather than impr

Software

Software · L4 · Site Reliability Engineering practice

@openstem

Note~623 words · 3 min

Replication Topologies Replication exists to survive node failure and to spread read load, but the topology chosen shapes the whole system's failure behavior. Leader-based (single-master) replication funnels writes through one node and stre

Software

Software · L4 · Distributed Systems Engineering

@openstem

Note~657 words · 3 min

The Service Mesh As the number of services grows, cross-cutting network concerns — mTLS, retries, timeouts, load balancing, circuit breaking, traffic splitting for canaries — become repeated work in every service's code. A service mesh move

Software

Software · L4 · Microservices Architecture & Resilience Patterns

@openstem

Note~207 words · 1 min

The Class NP A language L ⊆ {0,1}* is in NP if there exists a polynomial p and a polynomial-time deterministic verifier V such that for every x: NP-Hardness and NP-Completeness L is NP-hard if every language in NP reduces to L under polynom

Software

Software · L5 · NP-Completeness and Reductions

@openstem

Note~840 words · 4 min

Finite Automata and Regular Languages A deterministic finite automaton (DFA) is a 5-tuple M = (Q, Σ, δ, q₀, F): a finite state set Q, alphabet Σ, total transition function δ: Q × Σ → Q, start state q₀, and accepting states F ⊆ Q. Extend δ t

Software

Software · L5 · Automata Theory & Formal Languages

@openstem

Note~676 words · 3 min

Why Process Calculi Operational protocols like Paxos and Raft describe how a specific class of fault-tolerant systems reaches agreement. Process calculi sit one level up in abstraction: they are algebraic languages for describing and reason

Software

Software · L5 · Process Calculi: CSP, the π-Calculus, and Behavioural Equivalence

@openstem

Note~809 words · 4 min

Turing Machines as the Formal Model of Computation A Turing machine is M = (Q, Σ, Γ, δ, q₀, q_accept, q_reject): a finite control Q, input alphabet Σ, tape alphabet Γ ⊇ Σ ∪ {⊔}, transition function δ: Q × Γ → Q × Γ × {L, R}, start state q₀,

Software

Software · L5 · Computability Theory

@openstem

Note~764 words · 4 min

One-Way Functions: The Minimal Assumption Modern cryptography is built on computational hardness, not information-theoretic secrecy (with the exception of the one-time pad, which requires a key as long as the message). The foundational prim

Software

Software · L5 · Theoretical Cryptography: Hardness, Pseudorandomness, and Proof

@openstem

Note~739 words · 4 min

Relational Algebra as SQL's Semantics Codd's relational model (1970) represents data as relations — mathematically, subsets of a Cartesian product of attribute domains, i.e. sets of tuples. Relational algebra is the procedural counterpart:

Software

Software · L5 · Database Theory: Relational Algebra, Serializability, and Query Optimization

@openstem

Note~688 words · 3 min

Two Axes of Parallelism Training a large model at scale requires distributing computation across many accelerators, and there are two orthogonal ways to do it. Data parallelism replicates the entire model on every worker i and partitions a

Software

Software · L5 · Systems for Distributed Machine Learning

@openstem

Note~887 words · 4 min

Why Formal Semantics? A programming language's syntax says what programs look like; its semantics says what they mean — precisely and unambiguously enough to prove theorems about programs (does this optimisation preserve behaviour? does thi

Software

Software · L5 · Programming Language Semantics

@openstem

Note~852 words · 4 min

Dataflow Analysis as Fixpoint Computation Classical dataflow analysis attaches, to each point in a control-flow graph, an abstract fact drawn from a lattice (L, ⊑, ⊔, ⊓) — a partial order with meet and join. Each statement or CFG edge has a

Software

Software · L5 · Program Analysis & Abstract Interpretation

@openstem

Note~811 words · 4 min

Hoare Triples A Hoare triple {P} C {Q} states partial correctness: starting from any state satisfying precondition P, IF command C terminates, the resulting state satisfies postcondition Q. Partial correctness is deliberately silent on term

Software

Software · L5 · Hoare Logic & Program Verification

@openstem

Note~988 words · 5 min

Top-Down vs. Bottom-Up Parsing LL(1) parsers work top-down: starting from the grammar's start symbol, they predict which production to expand using the current nonterminal and one token of lookahead, requiring FIRST sets of alternative prod

Software

Software · L5 · Compiler Construction Theory

@openstem

Flowchart9 objects

Software

Language Basics · flowchart

@openstem

Flowchart9 objects

Software

Widgets & State · flowchart

@openstem

Flowchart11 objects

Software

OOP & Collections · flowchart

@openstem

Flowchart9 objects

Software

Web & REST Controllers · flowchart

@openstem

Flowchart9 objects

Software

Data & Optimization · flowchart

@openstem

Flowchart19 objects

Software

Software · L1 · JavaScript: Array Method Choices · flowchart

@openstem

Flowchart13 objects

Software

Software · L1 · TypeScript: Handling Optional and Nullish Values · flowchart

@openstem

Flowchart15 objects

Software

Software · L1 · Python: Choosing the Right Collection · flowchart

@openstem