Advanced Web Applications Development

After the day

Assessing it

Marking “did it run” stopped measuring anything the day a machine could produce the artefact. Four alternatives that still work, and the one skill they all test.

In this chapter

  • Why a finished submission is no longer evidence
  • Four ways to assess this that are not ‘did it run’
  • The five moves, and which of them each one tests

This is the page I would read first if you are taking the material into a module you have to grade.

The thing that broke

For a long time an assignment worked like this: you deliver the material, the student produces an artefact, and the artefact proves they learned something.

The second half of that stopped being true. When a machine can produce the artefact, the artefact is no longer evidence of anything. A working fare search proves that a fare search exists. It says nothing about who understands it.

That is not a reason to ban anything — a ban is unenforceable, and it trains people for a world that is not coming back. It is a reason to stop grading the artefact and start grading what someone can explain and defend about it.

Marking “did it run” rewards the pair who copied fastest.

Four alternatives that do not

  1. Find the planted bug. Hand them a branch where the search returns the oldest fare, or validation accepts a negative amount. Ask what is wrong, why it passed review, and what test would have caught it. This is the Lab D idea as an exam question.
  2. Explain it line by line. Give them twenty lines of working code — ideally code a model generated — and ask what each line does and what breaks if it is removed. Judgement is the thing you are teaching, and this measures it.
  3. Write the spec, not the code. Give them a feature in words. Ask for the schema change, the endpoint, the status codes and the tests — no implementation. Then let them generate the implementation and review it against their own specification.
  4. Review a pull request. Two pairs swap branches and review each other’s Lab B. Mark the review, not the code.

Each of those is still gradeable when the student used every tool available, because none of them is satisfied by a correct artefact.

What the four have in common

Directing a build is a different skill from building, and it has a shape worth naming for your students. Five moves:

  1. Define. What problem, for whom, and what does done mean? Most bad output traces back to a request nobody could have satisfied.
  2. Constrain. What must it not do, and what could it not possibly know — your stop ids, your status vocabulary, the fact that a route runs one way?
  3. Direct. Say how, not only what. “Build me an endpoint” and “build me an endpoint that returns 404 for an unknown route and 400 for an empty body” produce different work.
  4. Verify. Contact with reality. Send the request. Send the bad one. Read what actually came back.
  5. Own it. They sign the result. Nobody downstream cares who typed it.

The four assessments above are those moves, turned into questions:

Assessment Move it tests
Find the planted bug Verify
Explain it line by line Verify, and whether they could have recognised it
Write the spec, not the code Define, Constrain, Direct
Review a pull request Own it

The four labs train moves 2 and 4 directly: Lab B is a validator refusing what it must not accept, Lab D is the whole of move 4 and the only lab where a green suite is the wrong answer. Moves 1, 3 and 5 are the ones your module has room for and Friday does not.

Everything here is gradeable because the labs leave a trail: four checkpoint branches, a commit at the end of Lab B and Lab D, and a CI run on push. Work built in visible stages is harder to fake than work submitted once at midnight — not impossible, just harder, and it is the evidence you have.

What not to claim

Nobody knows how long this holds. Tools that check their own work are improving quickly, and anyone offering you a timeline is guessing.

What is already safe to teach: judgement, accountability, and knowing your own context outlast syntax by a long way. A 201 still means created. A unique constraint still refuses a duplicate at the only level that cannot be bypassed. Those are what a specification is written against and what a test verifies with — which is why the principles in these four labs are the content of the five moves, not an alternative to them.

Saved in this browser only.