system design

Authorization

The process of determining what an authenticated entity or user is permitted to do or access.

Authentication vs. Authorization

Authentication verifies identity (confirming who you are), whereas authorization checks permissions (determining what you may do).

Availability (System Design)

The proportion of time that a system remains operational and responds usefully within an acceptable timeframe.

Annual downtime permitted by $99.99\%$ availability

Approximately $52.6\,\text{minutes}$ per year.

Durability (ACID)

The guarantee that once a transaction is committed, its changes survive crashes, restarts, or power failures.

PostgreSQL: Impact of setting synchronous_commit = off

A transaction can be acknowledged before its write-ahead log (WAL) is flushed to disk, which may lead to recent committed data being lost after a crash.

Immutability (Architecture)

A design principle where existing data values are never overwritten in place; updates produce new values or append new records.

System design example of immutability

An append-only ledger that records new transactions instead of modifying or overwriting historical transactions.

Reliability

The capacity of a system to consistently execute correctly over time, tolerate faults, and fail gracefully.

Reliability vs. Availability

Availability measures whether a service is reachable and responds, whereas reliability measures whether the service behaves correctly over time.

Authentication

The process of verifying an entity's identity to confirm they are who they claim to be.

Process (Operating Systems)

An executing program instance with its own dedicated virtual address space and OS resources, containing one or more threads.

Memory sharing between separate processes

Separate processes cannot directly share memory because each has its own virtual address space; explicit inter-process communication (IPC) or shared memory regions are required.

Thread

An operating system execution unit inside a process that shares the process's memory space while keeping its own stack and register state.

Resources shared among threads in a process

The heap, global variables, executable code, and open file descriptors are shared; thread stacks and registers remain private.

Primary cause of multithreading data races

Multiple threads concurrently accessing and mutating shared memory without adequate synchronization, leading to unpredictable interleaving.

Lock contention

A concurrency bottleneck where multiple execution threads compete for the same lock, causing waiting, serialized execution, and reduced throughput.

Green threads (Goroutines)

Lightweight, user-space execution threads scheduled by a runtime or virtual machine rather than the operating system kernel.

Eventual consistency

A distributed data model where reads may temporarily return stale values, but all replicas eventually converge if write operations cease.

Real-world example of eventual consistency

A distributed social media like counter showing slightly different counts on different nodes until updates propagate across all replicas.

Strong consistency (Linearizability)

A model where operations behave as if executed on a single atomic copy of data; any read beginning after a write completes is guaranteed to observe that write or a later update.

Use case requiring strong consistency

High-contention inventory allocation, such as booking the final seat on a flight where two competing buyers cannot both succeed.

Circuit Breaker pattern

A system pattern that temporarily blocks requests to an unresponsive dependency to fail fast, protect resources, and periodically test for recovery.

Three operational states of a Circuit Breaker

Closed (requests flow normally), Open (calls fail fast without hitting the dependency), and Half-Open (a limited number of trial requests probe for dependency recovery).

Logarithm

The mathematical inverse of exponentiation; $\log_b(n) = x$ means that $b^x = n$.

Value of $\log_2(8)$

$3$, because $2^3 = 8$.

Mathematical reason Binary Search is $\mathcal{O}(\log(n))$

Each step halves the remaining search range; reaching a single element after $k$ iterations satisfies $\frac{n}{2^k} = 1$, giving $k = \log_2(n)$.

Effect of doubling input size in Binary Search

The required step count increases by approximately $1$ step because $\log_2(2n) = \log_2(n) + 1$.

Reason logarithm base is omitted in Big-O notation

Changing logarithmic bases simply scales the value by a constant factor via $\log_b(n) = \frac{\log_a(n)}{\log_a(b)}$, and constant factors are dropped in asymptotic analysis.

$$2^0$$

$$1$$

$$2^1$$

$$2$$

$$2^2$$

$$4$$

$$2^3$$

$$8$$

$$2^4$$

$$16$$

$$2^5$$

$$32$$

$$2^6$$

$$64$$

$$2^7$$

$$128$$

$$2^8$$

$$256$$

$$2^9$$

$$512$$

$$2^{10}$$

$$1024$$

$$\log_2(32)$$

$$5$$

$$\log_2(128)$$

$$7$$

$$\log_2(256)$$

$$8$$

$$\log_2(1024)$$

$$10$$