MIT 6.005 - Software Construction Flashcards

Question 1

What is **Abstraction** in software construction?

Accepted Answer

Abstraction is the process of simplifying complex systems by focusing on essential properties and hiding unnecessary details. It allows us to manage complexity by working with higher-level concepts.
*Example:* A `List` interface abstracts away the underlying data structure (e.g., `ArrayList`, `LinkedList`), allowing users to interact with a common set of operations without knowing the implementation details.

Question 2

Explain **Encapsulation** and its benefits.

Accepted Answer

Encapsulation is the bundling of data (attributes) and methods (functions) that operate on the data into a single unit, typically a class, and restricting direct access to some of the component's parts.
*Benefits:*
*   **Information Hiding:** Protects the internal state of an object from external manipulation.
*   **Modularity:** Makes the code easier to understand, maintain, and debug.
*   **Flexibility:** Allows internal implementation to change without affecting external users.

Question 3

Define **Immutability** and provide an example.

Accepted Answer

Immutability refers to an object whose state cannot be modified after it is created. Once an immutable object is initialized, its data remains constant.
*Benefits:*
*   **Thread Safety:** No race conditions for shared immutable objects.
*   **Simplicity:** Easier to reason about program state.
*   **Caching:** Can be safely cached and reused.
*Example:* Java's `String` class is immutable. When you perform an operation like `str.concat("world")`, it returns a *new* `String` object rather than modifying the original `str`.

Question 4

What is **Information Hiding** and why is it crucial?

Accepted Answer

Information hiding is the principle of concealing the internal implementation details of a software module from its clients. Clients should only interact with the module through its public interface.
*Crucial because:*
*   It reduces dependencies between modules.
*   Allows internal changes without breaking client code.
*   Simplifies reasoning about individual modules.
*   Supports modularity and maintainability.

Question 5

What is a **Module** in software construction?

Accepted Answer

A module is a self-contained, independent unit of software that performs a specific task or provides a specific set of functionalities. It typically has a well-defined interface and hidden internal implementation.
*Characteristics:* Cohesion (performs a single, well-defined task) and Loose Coupling (minimal dependencies on other modules).

Question 6

Explain the concept of a **Specification** for a method or module.

Accepted Answer

A specification is a precise, unambiguous description of what a method or module does, without revealing how it does it. It defines the contract between the implementer and the client.
*Key parts:*
*   **Preconditions:** Conditions that must be true *before* the method is called.
*   **Postconditions:** Conditions that will be true *after* the method completes, assuming preconditions were met.
*   **Returns:** Description of the return value.
*   **Throws:** Description of exceptions that might be thrown.

Question 7

What is a **Representation Invariant**?

Accepted Answer

A representation invariant (rep invariant) is a condition that must always be true for an object's internal state (its representation) at all times when the object is not actively executing one of its methods. It defines what a valid object looks like internally.
*Purpose:* To ensure the internal consistency and correctness of an object's data. It's checked at the beginning and end of public methods.

Question 8

Describe the **Abstraction Function**.

Accepted Answer

The abstraction function is a mapping from the concrete representation of an object (its internal state) to the abstract value that the object is intended to represent. It defines what the object "means" to its clients.
*Purpose:* To bridge the gap between the internal implementation details and the abstract concept the object embodies, helping to reason about correctness.

Question 9

What is a **Design Pattern**?

Accepted Answer

A design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It's not a finished design that can be directly transformed into code, but rather a description or template for how to solve a problem that can be used in many different situations.

Question 10

Explain the **Singleton Pattern**.

Accepted Answer

The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance.
*Use Case:* When exactly one object is needed to coordinate actions across the system (e.g., a logger, configuration manager, database connection pool).
*Example (Java sketch):*
```java
public class Singleton {
    private static Singleton instance;
    private Singleton() {} // Private constructor
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
```

Question 11

Describe the **Factory Method Pattern**.

Accepted Answer

The Factory Method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. It defers instantiation of an object to its subclasses.
*Use Case:* When a class cannot anticipate the class of objects it needs to create, or when a class wants its subclasses to specify the objects it creates.
*Example:* A `Document` interface with `createHeader()`, `createBody()`, `createFooter()` methods, where concrete `WordDocument` and `PdfDocument` classes implement these methods to return specific header/body/footer types.

Question 12

What is the **Strategy Pattern**?

Accepted Answer

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
*Use Case:* When you have multiple ways to perform a specific task (e.g., different sorting algorithms, different payment methods) and want to switch between them at runtime.
*Example:* A `PaymentProcessor` class that can use different `PaymentStrategy` implementations (e.g., `CreditCardPayment`, `PayPalPayment`).

Question 13

Define **Unit Testing**.

Accepted Answer

Unit testing is a software testing method where individual units or components of a software are tested in isolation. A "unit" is typically the smallest testable part of an application, such as a method or a class.
*Characteristics:*
*   **Isolated:** Tests only one unit, mocking dependencies.
*   **Fast:** Executes quickly.
*   **Automated:** Run frequently, often as part of CI/CD.
*Example:* Testing a `Calculator.add(a, b)` method to ensure it returns the correct sum for various inputs.

Question 14

Explain **Integration Testing**.

Accepted Answer

Integration testing is a phase in software testing in which individual software modules are combined and tested as a group. It aims to expose defects in the interfaces and interactions between integrated components.
*Characteristics:*
*   Tests interactions between multiple units.
*   Often involves real dependencies (e.g., database, external APIs).
*   Slower than unit tests.
*Example:* Testing a user registration flow that involves interacting with a UI, a backend service, and a database.

Question 15

What is **Regression Testing**?

Accepted Answer

Regression testing is the process of re-running functional and non-functional tests to ensure that previously developed and tested software still performs correctly after changes (e.g., bug fixes, new features, refactoring) have been made.
*Purpose:* To catch unintended side effects or new bugs introduced by recent code modifications. It's often automated and run frequently.

Question 16

Describe **Test-Driven Development (TDD)**.

Accepted Answer

TDD is a software development process where tests are written *before* the code that implements the functionality. The workflow is:
1.  **Red:** Write a failing test for a new feature.
2.  **Green:** Write just enough code to make the test pass.
3.  **Refactor:** Improve the code's design without changing its behavior, ensuring tests still pass.
*Benefits:* Forces clear design, reduces bugs, improves code quality.

Question 17

What is **Black-Box Testing**?

Accepted Answer

Black-box testing is a method of software testing that examines the functionality of an application without peering into its internal structures or workings. The tester is unaware of the internal code, design, or implementation details.
*Focus:* Input/output behavior, user interface, and overall functionality based on requirements.

Question 18

What is **White-Box Testing**?

Accepted Answer

White-box testing (also known as clear-box, glass-box, or structural testing) is a method of software testing that tests the internal structures or workings of an application, as opposed to its functionality. The tester has knowledge of the internal code, design, and implementation.
*Focus:* Code coverage (e.g., statement, branch, path coverage), logical paths, data flow.

Question 19

What is **Code Review** and its primary benefits?

Accepted Answer

Code review is a systematic examination of computer source code. It's typically performed by peers (developers other than the author) to find mistakes, improve code quality, and ensure adherence to coding standards.
*Benefits:*
*   **Bug Detection:** Catches defects early.
*   **Knowledge Sharing:** Spreads understanding of the codebase.
*   **Improved Code Quality:** Enforces best practices and consistency.
*   **Mentorship:** Helps less experienced developers learn.

Question 20

List key **Code Review Best Practices**.

Accepted Answer

*   **Keep reviews focused and timely:** Review small changes frequently.
*   **Set clear goals:** Focus on correctness, readability, maintainability, performance, security.
*   **Be constructive and empathetic:** Provide feedback, not criticism.
*   **Automate what you can:** Use linters, formatters, and static analysis tools.
*   **Reviewer diversity:** Get different perspectives.
*   **Follow up:** Ensure feedback is addressed.

Question 21

Explain **Defensive Programming**.

Accepted Answer

Defensive programming is a style of programming that aims to anticipate and handle potential errors, unexpected inputs, or abnormal conditions gracefully, rather than allowing them to crash the program or produce incorrect results.
*Techniques:* Input validation, assertions, error handling (exceptions), robust parameter checking.

Question 22

What are **Assertions** and when should they be used?

Accepted Answer

An assertion is a statement in a program that assumes a condition is true at a particular point in the code. If the condition evaluates to false, the program typically terminates or throws an error, indicating a bug.
*When to use:*
*   To check preconditions and postconditions of private methods.
*   To verify internal invariants.
*   To validate assumptions about program state that *should never* be false.
*   **Note:** Assertions are for *bugs* in the code, not for handling expected runtime errors or invalid user input.

Question 23

When should **Exceptions** be used in software?

Accepted Answer

Exceptions are a mechanism for handling exceptional, unexpected events or errors that disrupt the normal flow of program execution.
*When to use:*
*   For **recoverable errors** that a client might be able to handle (e.g., file not found, network connection lost, invalid user input).
*   To separate error-handling code from normal program logic.
*   When an operation cannot complete successfully due to external factors or invalid arguments from a client.
*   **Contrast with assertions:** Exceptions are for *expected* but *unusual* runtime conditions; assertions are for *unexpected* conditions indicating a *bug*.

Question 24

What is **Concurrency** in software, and what are its main challenges?

Accepted Answer

Concurrency is the ability of different parts of a program or multiple programs to execute independently and potentially in parallel. It allows multiple computations to happen at the same time.
*Main Challenges:*
*   **Race Conditions:** Multiple threads accessing shared data, leading to unpredictable results.
*   **Deadlock:** Two or more threads are blocked indefinitely, waiting for each other to release resources.
*   **Livelock:** Threads repeatedly change state in response to other threads, but no actual progress is made.
*   **Starvation:** A thread is perpetually denied access to a shared resource.
*   **Complexity:** Difficult to design, debug, and test concurrent programs.

Question 25

Define **Thread Safety** and how it can be achieved.

Accepted Answer

Thread safety refers to code that can be executed by multiple threads concurrently without causing data corruption or incorrect results. A thread-safe program behaves correctly even when multiple threads access shared mutable state.
*How to achieve:*
*   **Immutability:** Use immutable objects whenever possible.
*   **Synchronization:** Use locks (e.g., `synchronized` blocks/methods, `ReentrantLock`) to protect shared mutable data.
*   **Atomic Operations:** Use atomic classes (e.g., `AtomicInteger`) for single-variable updates.
*   **Thread-Local Storage:** Give each thread its own copy of data.
*   **Concurrent Collections:** Use thread-safe data structures (e.g., `ConcurrentHashMap`).

MIT 6.005 - Software Construction

Cards in this deck

Related Flashcard Sets

HSK 2 - Intermediate Chinese Vocabulary & Grammar

Genetics - Mendelian Inheritance & Population Genetics

USMLE Step 1 - General Principles of Pharmacology

Melbourne COMP90043 - Cryptography and Security