Skip to main content
ZhimaYuandi

PREDICT · DEBUG · RUN LOCALLY

From understanding code to delivering a small tool

Practice understanding, debugging and real verification through a Campus Resource Organizer. For first- and second-year students familiar with variables, conditions, loops and functions. Your year does not restrict your starting point.

Six fundamentals tasks, three data-structure labs and M1/M2/M3 projects are available, including local SQLite and transactional import. Model results, local tests and self-reports remain separate records.

Year 1 · Programming and debugging

Know basic syntax but need help debugging? Predict F01 output, inspect boundaries and repair real code on your computer.

Open F01 →

Year 2 · Structures and projects

Later units extend the same project with a stack, queue and indexes, then SQLite. Review boundaries, object copies and saving in F01–F06/M1, then move to the three labs and M2.

See the planned route →

A roughly five-minute starting check

Answer before revealing each explanation. These checks suggest review topics; they do not grade you or lock units.

Loop: which indices does range(3) include?

0, 1, 2. The stop value 3 is excluded. Start with F01 if unsure.

Return value: does printing a list return it to the caller?

No. print displays a value; return passes it to the caller. Review Python functions and return values, then try F01.

Position and identity: after removing the first item, does index 1 still identify the same document?

No. Positions can change; a stable ID does not change with position. Explore the distinction in F03.

Error: IndexError: list index out of range. What would you inspect first?

Inspect list length, the accessed index and loop bounds. Construct a minimal input; F01 practices exactly this.

Coming from C? A short Python bridge

Spend about 20–30 minutes getting familiar with this notation. This is a reading bridge, not mastery of Python, exceptions or file handling.

documents = [{"id": "doc_00000000000000000000000000000001",
              "title": "Notes", "category": "CS", "tags": ["week1"]}]

def ids(documents):
    result = []
    for document in documents:
        result.append(document["id"])
    return result

print(ids(documents))
  • Indentation defines blocks. Lists [] keep ordered items; dictionaries {} expose fields by key.
  • range(n) produces 0 through n-1; append adds an item; return passes a value back.
  • Python names may refer to the same mutable object. C pointer parameters are themselves passed by value. Do not treat these illustrations as real memory-address models.

Python · C · VSCode terminal

Local learning records

Saved only in this browser; export is available. No cross-device sync or proof of mastery. Earlier F01 and six-task records are preserved through migration.

  • F01 · Not opened · Local self-report: —
  • F02 · Not opened · Local self-report: —
  • F03 · Not opened · Local self-report: —
  • F04 · Not opened · Local self-report: —
  • F05 · Not opened · Local self-report: —
  • F06 · Not opened · Local self-report: —
  • D01 · Not opened · Local self-report: —
  • D02 · Not opened · Local self-report: —
  • D03 · Not opened · Local self-report: —
Continue F01

The 6 + 3 + 1 route

  1. F01 · Why did ten documents become nine?

    Loop ranges, boundaries and minimal counterexamples

  2. F02 · Why did a preview change the original?

    Parameters, return values and independent snapshots

  3. F03 · Why did deletion target the wrong document?

    List positions and stable identities

  4. F04 · Why does a different input break it?

    Validate before changing data

  5. F05 · Why did documents disappear after restart?

    JSON files, paths and error protection

  6. F06 · Why did filtering break existing features?

    Reproduction, regression and delivery

  7. D01 · Undo mistakes with a stack

    LIFO and independent history snapshots

  8. D02 · Keep batch work ordered with a queue

    FIFO, failure recovery and ring-buffer models

  9. D03 · Find and deduplicate with hash indexes

    Collisions, index consistency and costs

  10. PROJECT · Campus Resource Organizer

    M0 setup → M1 JSON → M2 structures → M3 SQLite

Milestones in one project

  1. M0 · Run the F01 demo and identify an intentionally failing test (available now)
  2. M1 · JSON foundation available: CRUD, filters and safe saving
  3. M2 · Data-structure edition available: undo, queues and two indexes
  4. M3 · SQLite, transactional import and delivery available

Open M1/M2/M3 and the delivery checklists →

Later delivery requires source code, real tests, a repair log, README, an independent change and peer reproduction feedback. Clicks and self-reports do not certify competence.

Review operating systems, networking and databases →