MIT 6.033 - Computer System Engineering

Soft modularity divides a system into components using conventions (e.g., function calls within a single memory space), but a bug in one component can crash the entire system. Hard modularity enforces strict boundaries using hardware or OS abstractions (e.g., separate processes via virtual memory), preventing errors in one module from directly corrupting another.

Hardware-enforced isolation achieved using page tables and a Memory Management Unit (MMU). It translates virtual addresses to physical addresses, isolates process address spaces, and restricts privileged kernel operations using CPU execution rings (e.g., user mode vs. kernel mode).

A core system design principle stating that functions placed at low levels of a system may be redundant or of little value compared to higher-level implementations. For example, end-to-end data integrity must be validated by the application at endpoints, as hop-by-hop network reliability does not guarantee application-level correctness.

An unintended dynamic condition where the output of a concurrent program depends on the non-deterministic sequence or timing of thread execution. Prevented by using synchronization primitives to enforce critical sections.

A synchronization primitive used to grant exclusive access to a shared resource. A thread calls lock() before entering a critical section and unlock() upon leaving, ensuring at most one thread executes the critical section at any time.

A synchronization primitive that allows threads to wait efficiently until a specific predicate becomes true. Used alongside a mutex with methods wait(mutex), signal(), and broadcast(). wait() atomically releases the lock and suspends execution until signaled.

Deadlock can only occur if all four conditions hold simultaneously:
1. Mutual Exclusion: Non-shareable access to resources.
2. Hold and Wait: Threads hold resources while waiting for others.
3. No Preemption: Resources cannot be forcibly taken away.
4. Circular Wait: A closed chain of threads exists where each waits for a resource held by the next.

An abstraction that allows a client application to execute a subroutine on a remote server as if it were a local function call, hiding network communication details like serialization and packet transmission.