Skip to main content
← AT CS Study Guide

Unit 0 · Bridge unit

Computer Science Foundations

The bridge from AP CSA into honors work. It re-establishes Java fluency and then adds the habits the rest of the course assumes: designing before coding, testing deliberately, and explaining a decision in writing.

What a strong answer looks like

A strong Unit 0 answer explains a design choice rather than only exhibiting working code.

Topics in this unit

1

Design Before Implementation

Know

Deciding responsibilities and interfaces before writing code is what makes a program changeable later. Design is a separate activity from coding, not a preamble to it.

Apply

Sketch the classes, their responsibilities, and how they interact before opening an editor.

Watch out

Starting to type immediately, which produces code that works and cannot be modified.

Study move

Take a working project and write, after the fact, the design you would have drawn first.

2

Abstraction and Encapsulation

Know

Abstraction hides how something is done behind what it does. Encapsulation is the mechanism: private state, public behavior.

Apply

Expose the smallest interface that lets callers do their job, and keep representation private.

Watch out

Leaking the representation through a getter, which freezes the implementation permanently.

Study move

Write a class whose internal storage could be swapped without any caller noticing.

3

Testing and Debugging Workflow

Know

A test plan is written from the specification, not from the implementation, so it can catch what the implementation got wrong.

Apply

Write the empty, single, typical, and boundary cases before the code, then run them after.

Watch out

Testing only the path you had in mind while coding, which confirms your assumptions rather than checking them.

Study move

Write a test plan for a method you have not implemented yet, then implement it.

4

Technical Communication

Know

Explaining an algorithm in prose is separately assessed in this course and is a genuine skill.

Apply

Describe what a method guarantees, what it assumes, and what it costs, in that order.

Watch out

Narrating the code line by line rather than explaining what it accomplishes and why.

Study move

Explain a recursive method in four sentences without referring to any line of code.

Emphasized in this unit

Connections and techniques that receive extra attention in this unit.

  • Designing an interface before an implementation
  • Writing tests from the specification rather than the code
  • Explaining decisions in prose

Varies by course

Related topics some schools attach to this unit and others leave out. Covered on request rather than assumed.

  • Version control. Git is required in some sections and optional in others.
  • IDE choice. Varies by school and does not affect assessment.

Mastery checklist

  • Sketch a class design from a problem statement.
  • Keep a representation private while exposing useful behavior.
  • Write a test plan covering empty, single, typical, and boundary cases.
  • Explain an algorithm without reading out the code.

Check yourself

  • What does encapsulation let you change later that a public field does not?
  • Why should a test plan come from the specification rather than the code?

Modeling drill

Take an AP CSA-era project and refactor it so that one class could have its internal storage replaced without changing any caller.

AbstractionEncapsulationInterfaceTest planBoundary caseRefactoring