Skip to content

Unit 1 Quiz

The goal of this page is to provide you with a single source of guidance on what to review and prepare for ahead of Quiz 1. The goal of the quiz is to assess your understanding of key concepts, ideas, and skills we have covered since the last quiz.

Task Learning Objectives

From TK04 - Professionalizing the Developer Environment

  1. What is a code formatter?
  2. What is a linter?
  3. What value does each uniquely provide to a software engineering team?
  4. How do you extend your IDE (such as VSCode) to support developer tools like formatting and linting?
  5. What is a static type checker?
  6. Why is a static type checker useful in Python?
  7. Why don't you need a separate tool for this in a language like Java?
  8. Why is "ceremony" required to write a test in a testing framework?
  9. What is coverage in the context of automated testing?
  10. What are fixtures and why are they important in testing?

From TK05 - Unit and Integration Testing Exercise

After successfully completing this exercise, you should be able to:

  1. Read and navigate a new codebase, understanding its structure and developer tooling.
  2. Explain the value of test-driven development (TDD) and apply the Red → Green → Refactor cycle.
  3. Write unit tests that verify individual components in isolation.
  4. Use mocks to isolate the subject under test from its composed dependencies.
  5. Use patches to intercept built-in library calls and test logic without side effects.
  6. Write integration tests that verify components work together with real dependencies.

These skills are foundational to the upcoming quiz and will be assessed in the context of your work on this task.

Lesson Learning Objectives

From LS05 - Designing with Layers and Composition

After lecture, you should be able to address:

  1. What is a strict layered architecture?
  2. What are common motivations and trade-offs in layered systems?
    • Separation of Concerns
    • Clear interfaces and contracts
    • Dependency direction
    • Replaceability
    • Maintainability
    • Testability
  3. The role object-oriented composition plays in layered software architectures.
  4. The role of Fake implementations via subclassing or interfaces and trade-offs.

From LS06 - AAA (Arrange, Act, Assert) Testing and Mocking

After lecture, you should be able to address:

  1. What do the steps of Arrange, Act, and Assert mean in practice? Why is it a valuable test design pattern?
  2. What is a test double? How is a Mock different from a Fake?
  3. What are some fundamental facilities of a MagicMock that support automated testing?

From LS07 - Testing with Patching and Fixtures

After lecture, you should be able to address:

  1. What is patching? When is it necessary? How does it relate to test doubles (fakes, mocks)?
  2. What is the utility of a fixture as it relates to automated testing?

From LS08 - Patching and Testing Practice

After lecture, you should be able to address:

  1. How do fixtures factor into the lifecycle of running one test? Multiple tests?
  2. When patching a name in a dynamic language like Python, why must you patch the name where it is used in Python and not where it is defined?

From LS09 - Models and Data Vadidation

After lecture, you should be able to address:

  1. What is a data model?
  2. What is data validation? Why is it important?
  3. What is the difference between declarative style programming vs. imperative? How is this exemplified in a data modeling library like Pydantic?

From RD13 - How AI Impacts Skill Formation

After reading, you should be able to address:

  1. What is a danger in over-reliance on AI generated code when learning new concepts?
  2. Why did conceptual inquiry, hybrid code-explanation, and generation-then-comprehension techniques seem to improve quiz scores over the other AI-involved methods?