====== Midterm Topics ======

    * The systems perspective
          * **System**: A set of interconnected components that has a specified behavior observed at the interface with its environment
          * System characteristics
                 * Emergent properties
                 * Propagation of effects
                 * Incommensurate scaling
                 * Trade-offs
          * Coping with complexity: **Modularity**
          * Modularity goals
                 * Performance
                 * Robustness/fault-tolerance
                 * Neutrality
                 * Simplicity
          * An OS is software that provides programs with access to an abstract machine
          * Protection and sharing
    * Interface design
          * readc: from one line at a time, through one character at a time, to one buffer at a time
          * Layering to improve interface usability while keeping performance
          * Optimization strategies: Caching and prefetching
    * Virtual computer
          * Three fundamental abstractions: link, interpreter, memory
          * Von Neumann computer characteristics
          * Virtual I/O, virtual processor, virtual memory
          * Hard modularity through client/service interaction
    * The process abstraction
          * Memory layout
          * Isolation properties
          * System calls & implementation
          * Protection levels & protected control transfer
          * File descriptors
          * Unix process and file system calls
          * Bounded buffers and pipes
          * Process hierarchy & zombie processes
          * Context switches
    * Threads
          * Process vs. thread
          * pthread_create, pthread_join, pthread_exit
          * Threads, stacks, and shared state (How does pthread_create differ from fork and why?)
    * Interrupts & signals
          * Unix signal system calls
          * Race conditions
    * Synchronization
          * One-writer principle
          * Indivisibility & atomicity
                * Isolation atomicity: Two sequences of steps are **isolated** if their effect from the point of view of the invokers (observers) is the same as if the sequences occurred either //completely before// or //completely after// one another.
                * What is an observer?
          * Critical section
          * Minimal critical section
          * Bounded buffer
          * Enforcing critical sections
          * Read/write coherence
          * Atomic instructions
          * Mutual exclusion locks
          * Lock contention
                * Coarse-grained vs. fine-grained locking
          * Deadlock
                * Waits-for graph
                * Lock ordering
          * Read/write locks
          * Blocking wait
                * Sleep-wakeup race
          * Semaphores
          * Condition variables
          * Utilization
    * Virtual memory
          * Domains and isolation
                * Processor support
                * And protection levels
          * Fragmentation, external and internal
          * Paged virtual memory
          * Isolation
                * Swapping
                * Thrashing
          * Performance
                * Demand paging