The Second Reader

For two years I lived in two versions of software at once.

By day I was an engineer on systems that had to keep running, writing code other people would read, depend on, and change long after I'd forgotten why I wrote it. By night I was a computer science student, handing in code that would be read exactly once, by one person, and then never run again.

I did well at the degree. I say that not as a boast but because it's the load-bearing fact of what follows: the marks were real, they measured something real, and what they measured was far narrower than it looked. Topping a module never answered the question the two years kept putting to me. It sharpened it. The same work, judged by the standard I used at my desk during the day, would not always have passed.

The Reader Who Never Comes

Start with the difference that turns out to explain everything else.

A university assignment is read once, by a marker, who never has to change it. They open it, judge it against a rubric, record a number and move on. The code's life ends at the moment it is understood.

Production code has a second reader. Someone comes later, a colleague or you in eight months, holding less context than you hold right now, and has to understand what you left well enough to change it without breaking it. Almost everything we call good engineering is, underneath, the discipline of writing for that person. Clear names, small units, decoupled parts, a test that explains its own intent: every one of them is a message to a reader who isn't in the room yet.

A degree has no second reader, so it never asks you to practise the one thing the job is mostly made of.

This isn't a complaint about lecturers or syllabi, and I want to be careful not to let it sound like one. It's structural. You cannot simulate a second reader inside an artefact that is handed in once and discarded, because the format forbids it. Whatever else a degree can do, and it can do a great deal, it can't make you write for someone who is never going to arrive.

Suspended, Not Absent

The obvious objection is that this is plainly false. Universities do teach maintainability. They mark for decoupling, they want tests, they ask for documentation, and, we'll come to this, they ask for rather a lot of comments. All true. The practices are on the rubric.

But watch what happens to a practice when the code is never touched again. It arrives as a rule with nothing underneath it. You're told to separate concerns and you're never made to feel the afternoon you'd lose if you didn't. You learn that you should decouple, and you're never once burned by the coupling, because nothing you submit ever has to survive a change. The practice is present and the reason is missing.

I've written before about the gap between knowing how and knowing why, about how a principle only sticks once you've felt the pain it answers and how before that it's just noise with good posture. A write-once degree is a machine for producing exactly that: knowing-how with the why suspended. Not wrong, not absent, but inert, a hook with nothing to catch on, because the experience that would fire it can't occur in a thing that's read once and thrown away.

And here's the part I'd ask any frustrated student to sit with, because it's the generous truth and the honest one at the same time. The same distance from consequence that stops a university teaching maintainability is exactly what lets it teach the theory. The deep, slow, immediately useless material, the proofs and the complexity and the foundations, is precisely what you'll never sit still for on the job, because the job rewards what pays off this week. A university's removal from consequence isn't only a weakness; it's the thing that buys the theory room to exist. Its great strength and its great blind spot are the same fact about it.

What Nothing Checks

Comments are the cleanest illustration, so let me use them, because the obsession is real and the lesson hides inside it.

There's a distinction the rubric rarely draws. A comment that restates what the code does is noise, and worse than noise, because it rots. A comment that captures why, the intent, the constraint that isn't visible, the reason the obvious approach was wrong here, is irreplaceable, because code can only ever say what it does. It can never say what it was permitted to do, or what it deliberately doesn't.

The trouble is that nothing checks a comment. The compiler runs the code; nothing runs the prose beside it. Code has a kind of gravity, in that it has to work, so reality keeps tugging it back toward the truth. A comment is under no such force. It can say one thing while the code three lines below it does another, and nothing anywhere will complain. So comments drift, not through carelessness but through the absence of anything that would catch the drift.

In a write-once world that drift never has time to bite. You comment the code, it's graded, it dies. You never meet the comment that has quietly lied for two years until it sends someone confidently in the wrong direction at the worst possible moment. So you leave with the habit and none of the scar, and you carry it into production, where the scar is waiting.

Hold onto the shape of that, because it's the whole essay: nothing checked the comment, so the comment drifted.

The Thing That Has to Be There

Now stand back and look at code, comments and your own understanding side by side, and ask what keeps each of them honest.

The code is kept honest by the compiler and the tests, which run it, so a lie stops the build. The design is kept honest by the second reader and by years of change, which exercise it, so a bad decision surfaces as pain. Your understanding is kept honest by doing, by shipping, by maintaining, by being wrong somewhere it costs you and having to look at why. In every case the thing stays true only because something forces it to. Remove the check and it drifts, quietly, without anyone noticing. The noticing was the check's whole job.

A claim that nothing ever tests drifts from the truth. That isn't a fact about university. It's a fact about knowledge. A belief you never expose to anything that could refute it isn't knowledge, it's a guess you've grown comfortable with. University is simply the purest specimen, because it removes every check at once, the future, the second reader, the test of running again, the cost of being wrong, and then prints a certificate saying the work is finished.

Not Behind, Elsewhere

I should answer the fair rebuttal, because it's a good one. Isn't this just what being a beginner is? Don't junior engineers also follow rules before they feel them?

They do. The difference is that the graduate isn't behind on the same road; they were standing somewhere the road doesn't reach. The junior on a team is inside the loop from the first week. They write the coupling on Monday and watch it cascade on Friday, and the rule attaches itself to fresh, specific pain. The student's environment can't produce that pain at all, because the code is never touched again. It isn't a slower version of the same process. It's a different place, missing the part that does the teaching.

I want to be precise about my own footing, because it would be easy to turn this into a flattering story and it isn't one. I only saw the gap because I happened to be standing in both places at once. Most students aren't, and that's no failing of theirs. My classmates weren't worse engineers waiting to catch up; they were doing the same work without the half of the loop that I, by the luck of having a job, got to supply from somewhere else. Take the job away and I'd have learned exactly what they learned. The vantage was circumstantial. The lesson isn't.

Why the Door Is Closing

For a long time none of this mattered very much, because the industry had a place to close the gap: the first job. You hired a graduate, and the early years were where the hooks got fired, through the ordinary repetitive work that teaches by repetition and consequence the things a degree structurally can't. The degree was never meant to produce a finished engineer. It produced foundations and the on-ramp did the rest.

Two things are wearing that on-ramp away at once. The repetitive work that used to be a junior's training ground is increasingly handed to machines, which means the at-bats that fired the hooks are vanishing. And tighter budgets have made firms less willing to pay for the stretch of time in which a graduate is becoming useful rather than being useful.

Here's the uncomfortable part, and I'd rather name it than smooth it over. The usual prescription is that universities should teach strong fundamentals and employers should recognise the degree for what it is. I believe the first half completely. The second half doesn't rescue the graduate; it more or less explains their predicament. If an employer correctly reads a degree as evidence of fundamentals and not of readiness, then in a market where the on-ramp is disappearing, the rational move is to hire fewer of the people whose hooks aren't fired yet. Recognising what the degree is doesn't open the door. It's part of why the door is closing.

So the responsibility moves onto the graduate. Not fairly, but really. The firing has to happen somewhere, and if the on-ramp won't supply it, you have to.

Build the Loop

The good news is genuine: a loop is a thing you can build, and you don't need anyone's permission to start.

What you need is code that outlives the moment you wrote it. Something you keep running. Something you're forced to come back to and change, and live with long enough to be embarrassed by. Go back to your own work from six months ago and feel, specifically, what your past self cost you. That flinch is the whole education, and a degree is the one place engineered to spare you from it. Put your code in front of a second reader, or contribute to something that already has one. The artefact barely matters. The loop is the part the degree had to leave out, and it was always the part doing the teaching.

The lesson reaches past software and past university, which is why I think it's worth writing down. Wherever you need something to stay true, whether that's a comment, a design, a belief, or a claim you make about yourself, find the thing that checks it. Where you can't find one, assume the drift has already started, because it has.

The second reader is the person the whole craft is quietly written for, the one who comes after you holding less than you hold now, who finds out whether what you left behind was true. A degree is the one place you never have to meet them, and everything afterwards is learning to write for them anyway.