MIT 6.031 - Software Construction: Testing, Immutability & Concurrency Flashcards

Question 1

Equivalence Partitioning

Accepted Answer

A black-box testing strategy that divides the input domain into subdomains (partitions) where the software is expected to behave similarly. You test at least one value from each partition to ensure representative coverage without redundant tests.

Question 2

Boundary Value Analysis (BVA)

Accepted Answer

A testing technique that complements equivalence partitioning by selecting test inputs at the exact edges (boundaries) of input subdomains (e.g., `0`, `min - 1`, `max + 1`). Bugs disproportionately occur at these boundary boundaries.

Question 3

Statement Coverage vs. Branch Coverage

Accepted Answer

**Statement Coverage** measures the percentage of executable lines executed by tests. **Branch Coverage** measures whether every decision point (e.g., `if`/`else` branches) evaluates to both `true` and `false`. Branch coverage is strictly stronger than statement coverage.

Question 4

Test-Driven Development (TDD) Cycle

Accepted Answer

A software development process relying on short, repeating iterations:
1. **Red**: Write a failing unit test for the intended feature.
2. **Green**: Write the minimum code required to pass the test.
3. **Refactor**: Clean up the code while ensuring all tests continue to pass.

Question 5

Mutable vs. Immutable Objects

Accepted Answer

A **mutable** object's state can be changed after creation (e.g., Java `StringBuilder`, Python `list`). An **immutable** object's state cannot be altered once instantiated (e.g., Java `String`, Python `tuple`), making it inherently safe to share across threads.

Question 6

Representation Invariant (Rep Invariant / RI)

Accepted Answer

A property or boolean condition that must always evaluate to `true` for every valid instance of an Abstract Data Type (ADT). It is typically verified at the end of constructors and mutator methods using a helper method like `checkRep()`.

Question 7

Abstraction Function (AF)

Accepted Answer

A conceptual mapping that defines how concrete field values in a class's internal representation ($R$) map to the abstract value space ($A$) it represents: $	ext{AF}: R 	o A$.

Question 8

Representation Exposure

Accepted Answer

A security and correctness bug where internal mutable data structures are exposed directly to clients via constructors or getter methods, allowing external code to modify internal state and violate the Rep Invariant.

Question 9

Defensive Copying

Accepted Answer

The technique of creating duplicates of mutable objects when accepting them in constructors or returning them in getter methods, preventing client code from modifying internal private state.

Question 10

Thread Safety

Accepted Answer

A property of a data structure or module indicating that it behaves correctly when accessed concurrently by multiple threads, regardless of execution scheduling, without requiring external synchronization.

Question 11

Race Condition

Accepted Answer

A concurrency defect where the correctness of a program depends on the relative execution order or interleaving of multiple threads accessing shared mutable state.

Question 12

Data Race vs. Race Condition

Accepted Answer

A **Data Race** occurs when two concurrent threads access the same memory location without synchronization and at least one access is a write. A **Race Condition** is a higher-level semantic bug where thread execution timing dictates program correctness, even if individual accesses are synchronized.

Question 13

4 Strategies for Thread Safety

Accepted Answer

1. **Confinement**: Do not share data between threads (thread-local state).
2. **Immutability**: Share data, but make state unmodifiable.
3. **Thread-Safe Data Structures**: Encapsulate data in existing thread-safe types (e.g., `ConcurrentHashMap`).
4. **Synchronization**: Use locks (`synchronized`, `ReentrantLock`) to enforce mutual exclusion.

Question 14

Monitor Pattern & Intrinsic Locks

Accepted Answer

In Java, every object has an implicit intrinsic lock (monitor). The `synchronized` keyword acquires this monitor before entering a method or block and releases it on exit, guaranteeing mutual exclusion and visibility across threads.

Question 15

Deadlock

Accepted Answer

A condition in concurrent programming where two or more threads are permanently blocked, each waiting for a lock or resource held by another thread in the waiting set.

Question 16

Coffman Conditions for Deadlock

Accepted Answer

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

Question 17

Lock Ordering Strategy

Accepted Answer

A design strategy to prevent deadlocks by establishing a global strict ordering on all locks. If all threads acquire required locks in the same predefined order (e.g., acquire $L_1$ before $L_2$), circular wait becomes impossible.

Question 18

Mutex vs. Counting Semaphore

Accepted Answer

A **Mutex** (Mutual Exclusion Lock) allows only one thread at a time to access a critical section. A **Counting Semaphore** maintains $N$ permits, allowing up to $N$ threads concurrent access to a shared resource pool.

Question 19

Thread Interference & Atomic Operations

Accepted Answer

Thread interference occurs when non-atomic operations (like `count++`, which expands to read-modify-write) interleave across threads, causing lost updates. Atomicity can be restored using lock synchronization or lock-free atomic types like `AtomicInteger`.

Question 20

The `volatile` Keyword in Java

Accepted Answer

Ensures that updates to a variable are immediately written to main memory and made visible to all threads, bypassing CPU caches. It guarantees memory visibility, but does **not** guarantee atomicity for compound operations like `i++`.

MIT 6.031 - Software Construction: Testing, Immutability & Concurrency

Cards in this deck

Related Flashcard Sets

HSK 1 - Basic Chinese Vocabulary, Pinyin & Character Recognition

Functional Programming - Immutability, Pure Functions & Higher-Order Functions

Neuroscience - Neuroanatomy & Brain Function

Microsoft Azure Administrator (AZ-104) - Compute, Storage & Networking