Interview Review Checklist

Every review in this module has examined a piece of engineering work. This one examines your own preparation, and it is the only review in the module where the reviewer and the subject are the same person — which is precisely why it needs a checklist rather than a feeling.

The review question this chapter turns on, asked of every topic:

Could I rebuild this without the page?

Revision produces a feeling of readiness that is almost entirely recognition. The page looks familiar, the terms are known, and nothing can be reconstructed once the page is closed. The feeling is identical in both states, which is what makes it useless as a signal and what makes this checklist necessary.

1. Recognition, Recall And Derivation

There are three states you can be in with respect to any topic, and only one of them is what an interview asks for.

Reading moves you from nothing to recognised and stops there. The two steps that matter — recalled, and derived — happen only when the page is closed, and the only way to find out which state you are in is to close it.

That is the whole chapter in three rows, and the nine review items below are nine specific ways the distinction shows up under questioning.

2. How To Use This Chapter

Each of the nine review dimensions below is a working review item, and every one answers the same seven questions:

These models score a property of an ANSWER, not a person. None of them is an interview rubric, none is a scoring system anybody should apply to a candidate, and each one's header says so. They exist so that "I know this" can be made falsifiable against yourself — which is the only use they have.

3. The One-Sentence Model

A topic is prepared when you have read it, when you can derive its numbers rather than recall them, when you can name a mechanism rather than restate a definition, when you can say where the claim stops being true, when you can name what it costs as well as what it buys, and when you have said all of that out loud at least once — and "I have read it" is bit 0.

4. What This Chapter Owns

The boundary with the rest of the module is the point of the chapter. Every earlier chapter taught something. This one asks whether the teaching landed, and it asks in the only way that produces an honest answer: with the page closed and the words spoken.

5. Teaching-Model Boundary And Source Discipline

Every model in this chapter is a teaching model. Each isolates one property of an answer so it can be examined, mutated and broken on purpose. None is an interview rubric, a scoring system, or an assessment of any person.

Nothing here states a normative CXL detail. No opcode, field width, bit position, register layout, response encoding, timing guarantee, revision number or specification figure appears anywhere in this chapter. The one numeric example that looks like a protocol figure — the bandwidth-delay derivation in section 9 — uses illustrative parameters in units per hundred cycles, and the model header says so.

One framing choice needs stating up front. These models express preparation as booleans and counters because that is what makes a property mutable and therefore testable. A real answer is not a six-bit mask, and nothing here should be read as a claim that it is. The mask is a device for making "I know this" falsifiable, and its value is entirely in the falsification.

6. Review Item 1 — Recognised, Recalled, Or Derived?

Under review. Every topic you believe you know.

What it distinguishes. Familiarity from capability.

The failure. Revision produces a comfortable feeling that is almost entirely recognition. The page looks familiar, the term is known, and nothing can be reconstructed without it.

// RTL 1 - recognising a term and being able to derive it are different states.
//
// Revision produces a comfortable feeling that is almost entirely recognition:
// the page looks familiar, the term is known, and nothing can be reconstructed
// without it. An interview asks for the third state, and the only way to find
// out which one you are in is to close the page.
//
//   RECOGNISED : you know the term when you see it
//   RECALLED   : you can produce the term unprompted
//   DERIVED    : you can rebuild the idea from something more basic
//
// TEACHING MODEL. It scores a PROPERTY OF AN ANSWER, not a candidate, and it is
// not an interview rubric. It contains no opcode, layout, encoding, register
// definition or timing figure from any specification.
module answer_depth #(parameter int RECOGNITION_IS_READY = 0) (
  input  logic clk, rst_n,
  input  logic       assess,
  input  logic       recognised, recalled, derived,
  output logic [7:0] level, n_assessed, n_overrated,
  output logic       ready, reported_ready,
  output logic       rec_err
);
  // The level is the deepest state genuinely reached.
  assign level = derived ? 8'd3 : recalled ? 8'd2 : recognised ? 8'd1 : 8'd0;
  // The truth: an answer is interview-ready when it can be rebuilt, not when
  // it can be spotted.
  assign ready = derived;
  // The whole review point.
  assign reported_ready = (RECOGNITION_IS_READY != 0) ? recognised : ready;
  // The revision has produced a false reading of its own state.
  assign rec_err = assess && reported_ready && !ready;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_assessed <= 8'd0; n_overrated <= 8'd0;
    end else if (assess) begin
      n_assessed <= n_assessed + 8'd1;
      if (reported_ready && !ready) n_overrated <= n_overrated + 8'd1;
    end
  end
endmodule

The measurement. A topic that is recognised and nothing more:

recognised only : level=1 ready=0 recognition_says=1

Level 1 of 3, and the recognition-is-ready build reports ready. That build is not a strawman — it is the state every reader is in at the end of a page, and its report is the feeling you finish reading with.

Evidence to demand of yourself. Close the page and say the idea out loud. If you cannot start the sentence, you are at level 1 whatever the feeling says.

What escapes. An interview where every topic is familiar and none can be built, which is the specific failure that feels most unfair afterwards.

How to rehearse it. Read, close, explain, reopen and check. The reopen is what converts the drill into evidence, and skipping it leaves you grading your own recall with the answer sheet closed.

Misleading evidence. Fluency while reading. The sentence makes sense as you read it, and that experience is identical whether you could have produced it or not.

Figure 1 — the two arrows on the bottom row are the whole difference between revision that works and revision that feels like it works. Reading terminates at level 1. Everything past it requires the page to be closed.

7. Review Item 2 — Is That A Mechanism Or A Definition?

Under review. Every answer to "what is X".

What it distinguishes. Restating a term from explaining one.

The failure. "It keeps the caches coherent" restates the question. The answer an interviewer is listening for names a mechanism: what structure holds the information, what event changes it, and what would break if it did not exist. A definition and a mechanism sound similar and are separated by exactly one follow-up.

// RTL 2 - a definition is not an answer.
//
// "It keeps the caches coherent" restates the question. The answer an
// interviewer is listening for names a MECHANISM: what structure holds the
// information, what event changes it, and what would break if it did not exist.
// A definition and a mechanism sound similar and are separated by one follow-up.
//
//   BAD  : the term, restated in different words
//   GOOD : the structure, the event that changes it, and the failure it prevents
//
// TEACHING MODEL.
module mechanism_named #(parameter int DEFINITION_COUNTS = 0) (
  input  logic clk, rst_n,
  input  logic answer_given,
  input  logic restates_term, names_structure, names_event, names_failure,
  output logic [7:0] parts_named, n_answers, n_hollow,
  output logic       is_mechanism, accepted,
  output logic       defn_err
);
  assign parts_named = {7'd0, names_structure} + {7'd0, names_event}
                     + {7'd0, names_failure};
  // The truth: a mechanism names all three parts.
  assign is_mechanism = (parts_named == 8'd3);
  // The whole review point: what the answer is judged on.
  assign accepted = (DEFINITION_COUNTS != 0) ? restates_term : is_mechanism;
  // A definition was accepted as an answer.
  assign defn_err = answer_given && accepted && !is_mechanism;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_answers <= 8'd0; n_hollow <= 8'd0;
    end else if (answer_given) begin
      n_answers <= n_answers + 8'd1;
      if (accepted && !is_mechanism) n_hollow <= n_hollow + 8'd1;
    end
  end
endmodule

The measurement. An answer naming the structure and the event, but not the failure it prevents:

structure + event, no failure : parts=2 mechanism=0 definition_accepts=1

Two of three parts is not a mechanism. The missing third — what breaks without it — is the part that shows the structure was understood rather than memorised, and it is the part most often left out because it feels like editorialising.

Evidence to demand of yourself. For each topic, three sentences: the structure, the event that changes it, and the failure it prevents. If you cannot write the third, you have a definition.

What escapes. An answer that sounds complete, followed by a follow-up that has nowhere to go.

How to rehearse it. Take any term you would use in an answer and write its three parts. The exercise takes two minutes per term and it is the single highest-yield drill in this chapter.

8. Review Item 3 — How Deep Does It Hold?

Under review. Every rehearsed answer.

What it distinguishes. An answer you built from an answer you memorised.

The failure. Most prepared answers are one question deep. The interviewer's second question is not adversarial; it is how they find the edge of what you built yourself.

// RTL 3 - the answer that survives one follow-up and not two.
//
// Most prepared answers are one question deep. The interviewer's second
// question is not adversarial; it is how they find the edge of what you built
// yourself versus what you memorised. An answer that holds through three is an
// answer you own.
//
//   BAD  : rehearse the answer
//   GOOD : rehearse the answer, then ask yourself "why" twice more
//
// TEACHING MODEL. Sequential.
//   State remembered : how deep the current answer has survived.
module follow_up_depth #(parameter int FIRST_ANSWER_IS_ENOUGH = 0) (
  input  logic clk, rst_n,
  input  logic ask, q1_ok, q2_ok, q3_ok, assess,
  output logic [7:0] depth_reached, n_questions, n_shallow,
  output logic       survives, reported_solid,
  output logic       follow_err
);
  logic [7:0] d_q;

  assign depth_reached = d_q;
  // The truth: an answer is solid when it holds through the third follow-up.
  assign survives = q1_ok && q2_ok && q3_ok;
  // The whole review point.
  assign reported_solid = (FIRST_ANSWER_IS_ENOUGH != 0) ? q1_ok : survives;
  assign follow_err = assess && reported_solid && !survives;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      d_q <= 8'd0; n_questions <= 8'd0; n_shallow <= 8'd0;
    end else begin
      if (ask) begin
        n_questions <= n_questions + 8'd1;
        // One assignment, computed from all three outcomes.
        d_q <= q1_ok ? (q2_ok ? (q3_ok ? 8'd3 : 8'd2) : 8'd1) : 8'd0;
      end
      if (assess && reported_solid && !survives) n_shallow <= n_shallow + 8'd1;
    end
  end
endmodule

The measurement. An answer that holds through the first question and fails the second:

holds q1, fails q2 : depth=1 survives=0 first_answer_says=1

Depth 1 of 3. The first-answer-is-enough build reports solid, which is what a rehearsed answer feels like from the inside — the rehearsal covered the first question and stopped, because the first question was the one you rehearsed.

Evidence to demand of yourself. After each prepared answer, ask yourself the obvious follow-up, then the follow-up to that. Three deep is the target.

What escapes. A strong opening answer that visibly thins under the second question, which reads worse than a modest answer that holds.

How to rehearse it. Write the answer, then write the two questions you would least like to be asked about it. Those two are the interview.

9. Review Item 4 — Can You Rebuild The Number?

Under review. Every figure you have memorised.

What it distinguishes. A recalled number from a derived one.

The failure. A memorised figure is worth one question. A derivation is worth every question in its family, and it survives a change of parameters mid-interview — which is the specific thing interviewers do to find out which you have.

// RTL 4 - the number you can rebuild beats the number you memorised.
//
// A memorised figure is worth one question. A derivation is worth every
// question in its family, and it survives a change of parameters mid-interview.
// The bandwidth-delay relationship is the clearest example: outstanding over
// round trip, and everything else follows.
//
//   BAD  : recall a figure
//   GOOD : rebuild it from a relationship, and say what it depends on
//
// TEACHING MODEL. Every figure is an illustrative parameter, in units per
// hundred cycles. None is a CXL specification number.
module derive_the_number #(parameter int MEMORISED_ONLY = 0) (
  input  logic clk, rst_n,
  input  logic        asked, parameters_changed,
  input  logic [7:0]  slots, rtt_cycles, memorised,
  output logic [15:0] derived_rate, answer_given,
  output logic        survives_change, correct,
  output logic [7:0]  n_asked, n_wrong,
  output logic        wb_err
);
  logic [31:0] d_q;

  assign d_q = (rtt_cycles == 8'd0) ? 32'd65535
             : (({24'd0, slots} * 32'd100) / {24'd0, rtt_cycles});
  assign derived_rate = (d_q > 32'd65535) ? 16'd65535 : d_q[15:0];
  // The whole review point: what the candidate produces when asked.
  assign answer_given = (MEMORISED_ONLY != 0) ? {8'd0, memorised} : derived_rate;
  assign correct = (answer_given == derived_rate);
  // A derivation still holds when the parameters move; a memorised figure does
  // not, and that is what the follow-up is for.
  assign survives_change = (MEMORISED_ONLY != 0) ? !parameters_changed : 1'b1;
  assign wb_err = asked && !correct;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_asked <= 8'd0; n_wrong <= 8'd0;
    end else if (asked) begin
      n_asked <= n_asked + 8'd1;
      if (!correct) n_wrong <= n_wrong + 8'd1;
    end
  end
endmodule

The measurement. The outstanding-slot count doubled mid-question:

slots doubled to 40 : derived=80 memorised_answers=40

The derived answer tracks the change and the memorised one does not. Both were correct a moment earlier. The parameter change is what separates them, and it costs the interviewer one sentence.

Every figure here is an illustrative parameter in units per hundred cycles. None is a CXL specification number, and the point of the item is the relationship rather than the value.

Evidence to demand of yourself. For every number you would quote, the relationship it comes from and what it depends on. If the answer is "I read it", it is worth one question.

What escapes. An answer that was right until the interviewer changed one input, and then visibly had nothing behind it.

How to rehearse it. Take each number you have memorised and write the expression that produces it. Then change an input and recompute. Two minutes per figure, and it converts a fact into a family of answers.

10. Review Item 5 — Where Does The Claim Stop Being True?

Under review. Every general statement you would make.

What it distinguishes. A claim that was reasoned from one that was absorbed.

The failure. "Coherent attach is faster" is true somewhere and false somewhere else. A candidate who names the boundary sounds more senior than one who does not — not because boundaries are impressive, but because naming one is what shows the claim was reasoned. An unbounded claim is also the easiest thing in an interview to disprove, and the disproof is what gets remembered.

// RTL 5 - where does your claim stop being true?
//
// Every useful statement has a boundary, and a candidate who states it sounds
// more senior than one who does not - because naming the boundary is what shows
// the claim was reasoned rather than absorbed. An unbounded claim is also the
// easiest thing in an interview to disprove, and the disproof is remembered.
//
//   BAD  : "coherent attach is faster"
//   GOOD : "faster for this access pattern, up to this working-set size, and
//           slower past it - here is why the crossover exists"
//
// TEACHING MODEL.
module claim_boundary #(parameter int UNBOUNDED_CLAIM = 0) (
  input  logic clk, rst_n,
  input  logic       state_claim,
  input  logic [7:0] operating_point, boundary_point,
  output logic [7:0] n_claims, n_overreach,
  output logic       holds_here, boundary_stated, claim_made, over_general,
  output logic       bound_err
);
  // The claim is true below its boundary and false above it.
  assign holds_here      = (operating_point <= boundary_point);
  // The whole review point: whether the claim carries its own limit.
  assign boundary_stated = (UNBOUNDED_CLAIM != 0) ? 1'b0 : 1'b1;
  assign claim_made      = state_claim;
  assign over_general    = claim_made && !boundary_stated && !holds_here;
  assign bound_err       = over_general;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_claims <= 8'd0; n_overreach <= 8'd0;
    end else if (state_claim) begin
      n_claims <= n_claims + 8'd1;
      if (over_general) n_overreach <= n_overreach + 8'd1;
    end
  end
endmodule

The measurement. A claim stated at an operating point past its boundary:

operating at 80, boundary 50 : holds=0 bounded_states=1 unbounded_states=0

The claim does not hold at 80 and the bounded build still makes a statement — the statement that includes the boundary, which is true at every operating point. The unbounded build says nothing it can defend, because the only claim it knows how to make is false here.

Evidence to demand of yourself. For each claim: the condition under which it holds, the condition under which it reverses, and roughly where the crossover is. Three clauses, and the third is the one that turns a slogan into an answer.

What escapes. A confident general statement, a counter-example from the interviewer, and a conversation that does not recover.

How to rehearse it. Take every claim in your preparation and write the case where it is false. If you cannot find one, either the claim is a tautology or you have not understood it.

11. Review Item 6 — Did You Name What It Costs?

Under review. Every architectural choice you would advocate.

What it distinguishes. Somebody who has shipped the thing from somebody who has read about it.

The failure. Every architectural choice costs something, and a candidate who names only the gain has either not looked or is selling. The cost is where the real conversation starts.

// RTL 6 - name both sides, or you have named neither.
//
// Every architectural choice costs something, and a candidate who names only
// the gain has either not looked or is selling. The cost is where the real
// conversation starts, and offering it unprompted is the single cheapest way to
// sound like somebody who has shipped the thing rather than read about it.
//
//   BAD  : "coherent attach gives you a single address space"
//   GOOD : "...and it costs a snoop on the critical path, which is why you
//           would not use it for streaming"
//
// TEACHING MODEL.
module trade_off_named #(parameter int GAIN_ONLY = 0) (
  input  logic clk, rst_n,
  input  logic answer_given,
  input  logic gain_named, cost_named, crossover_named,
  output logic [7:0] sides_named, n_answers, n_one_sided,
  output logic       balanced, accepted,
  output logic       trade_err
);
  assign sides_named = {7'd0, gain_named} + {7'd0, cost_named}
                     + {7'd0, crossover_named};
  // The truth: a trade-off is named when both sides AND the crossover are.
  assign balanced = gain_named && cost_named && crossover_named;
  // The whole review point.
  assign accepted = (GAIN_ONLY != 0) ? gain_named : balanced;
  assign trade_err = answer_given && accepted && !balanced;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_answers <= 8'd0; n_one_sided <= 8'd0;
    end else if (answer_given) begin
      n_answers <= n_answers + 8'd1;
      if (accepted && !balanced) n_one_sided <= n_one_sided + 8'd1;
    end
  end
endmodule

The measurement. An answer naming the gain and the cost, and stopping there:

gain and cost named, crossover not : sides=2 balanced=0 gain_only_accepts=1

Two of three, and it is not a trade-off yet. The crossover is where the trade-off becomes actionable — an answer without it leaves the interviewer to supply the only part that decides anything.

This case was missing from the first campaign, and a mutation found it

The stimulus drove a one-sided answer and a complete one, and nothing in between. A mutation dropping the crossover from the test survived, because the middle case — both sides named, crossover left out — was never driven.

That gap is the review item's own subject. It is exactly the shape of revision that produces a candidate who can state both sides of every trade-off and cannot say when to pick which. Section 19 records it, and the habit that prevents it generalises: for a condition with N parts, drive all N cases with exactly one part missing.

Evidence to demand of yourself. For each choice: the gain, the cost, and the operating point where the answer flips.

How to rehearse it. Offer the cost unprompted. It is the single cheapest way to sound like somebody who has shipped the thing, and it costs one clause.

12. Review Item 7 — Three Levels Of Why

Under review. Every topic, to the depth you have taken it.

What it distinguishes. Understanding the problem from understanding the solution.

The failure. The first why is usually answerable from memory. The second reaches the mechanism. The third reaches the constraint that made the mechanism necessary, and that is where an interview decides which of the two you have.

// RTL 7 - three levels of why.
//
// The first "why" is usually answerable from memory. The second reaches the
// mechanism. The third reaches the constraint that made the mechanism
// necessary, and that is where an interview decides whether you understand the
// problem or the solution. Rehearsing to level three is the whole preparation.
//
//   Level 1 : what it does
//   Level 2 : how it does it
//   Level 3 : what would go wrong without it, and what that costs
//
// TEACHING MODEL. Sequential.
module three_whys #(parameter int ONE_LEVEL_IS_ENOUGH = 0) (
  input  logic clk, rst_n,
  input  logic ask_why, assess, what_ok, how_ok, why_ok,
  output logic [7:0] levels_deep, n_topics, n_thin,
  output logic       deep_enough, reported_deep,
  output logic       depth_err
);
  logic [7:0] lv_q;

  assign levels_deep = lv_q;
  // The truth: level three is reached only if all three hold in order.
  assign deep_enough = what_ok && how_ok && why_ok;
  // The whole review point.
  assign reported_deep = (ONE_LEVEL_IS_ENOUGH != 0) ? what_ok : deep_enough;
  assign depth_err = assess && reported_deep && !deep_enough;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      lv_q <= 8'd0; n_topics <= 8'd0; n_thin <= 8'd0;
    end else begin
      if (ask_why) begin
        n_topics <= n_topics + 8'd1;
        // One assignment, computed from all three levels.
        lv_q <= what_ok ? (how_ok ? (why_ok ? 8'd3 : 8'd2) : 8'd1) : 8'd0;
      end
      if (assess && reported_deep && !deep_enough) n_thin <= n_thin + 8'd1;
    end
  end
endmodule

The measurement. What and how, with no why:

what and how, no why : levels=2 deep_enough=0 one_level_says=1

Level 2 of 3 is the most common state of a well-prepared candidate, and it is the state that produces a good interview rather than a decisive one. The one-level build reports deep, which is what level 2 feels like.

Evidence to demand of yourself. For each topic, the third answer written down. The first two are usually already there.

How to rehearse it. Ask why twice more than feels necessary. The third answer is almost always a constraint — a cost, a physical limit, a compatibility requirement — and constraints are what interviews are actually about.

13. Review Item 8 — What Do You Do When You Do Not Know?

Under review. Every question you cannot answer.

What it distinguishes. An admitted gap from a confident wrong answer.

The failure. A confident wrong answer costs more than an admitted gap, because it makes every other answer in the interview uncertain. An admitted gap costs one question — and an admitted gap followed by a method costs nothing at all.

// RTL 8 - "I don't know, and here is how I would find out."
//
// A confident wrong answer costs more than an admitted gap, because it makes
// every other answer in the interview uncertain. An admitted gap costs one
// question - and an admitted gap followed by a method costs nothing at all, and
// is often the answer that is remembered.
//
//   WORST : confidently wrong
//   OK    : honestly unsure
//   BEST  : honestly unsure, plus how you would resolve it
//
// TEACHING MODEL. It scores a property of an ANSWER; it is not a rubric for a
// person.
module honest_gap #(parameter int NEVER_SAY_UNSURE = 0) (
  input  logic clk, rst_n,
  input  logic asked, knows_it, method_given,
  output logic [7:0] n_asked, n_confidently_wrong, trust_cost,
  output logic       answered, admitted, confidently_wrong,
  output logic       trust_err
);
  // The whole review point: what the candidate does when they do not know.
  assign answered  = knows_it || (NEVER_SAY_UNSURE != 0);
  assign admitted  = !knows_it && (NEVER_SAY_UNSURE == 0);
  assign confidently_wrong = !knows_it && answered;
  // An admitted gap costs one; an admitted gap with a method costs nothing; a
  // confident wrong answer costs three, because it taints the answers around it.
  assign trust_cost = confidently_wrong ? 8'd3
                    : (admitted ? (method_given ? 8'd0 : 8'd1) : 8'd0);
  assign trust_err = asked && confidently_wrong;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_asked <= 8'd0; n_confidently_wrong <= 8'd0;
    end else if (asked) begin
      n_asked <= n_asked + 8'd1;
      if (confidently_wrong) n_confidently_wrong <= n_confidently_wrong + 8'd1;
    end
  end
endmodule

The measurement. A candidate who does not know and offers a method:

does not know, offers a method : admits=1 cost=0 never_unsure_cost=3

Zero cost against three. The never-say-unsure build answers everything and pays for it — not once per wrong answer, but across the whole interview, because an interviewer who has found one confident wrong answer now has to re-weigh the rest.

Evidence to demand of yourself. A rehearsed sentence for not knowing. It should end with how you would find out, and having it rehearsed is what stops the reflex to guess.

What escapes. A strong interview undone by one invented answer, which is a genuinely common outcome and an entirely avoidable one.

14. Review Item 9 — How Many Have You Said Out Loud?

Under review. Your revision coverage.

What it distinguishes. Topics read from topics rehearsed.

The failure. Revision coverage is usually counted in topics read, and the number that predicts an interview is topics said out loud. The gap between them is invisible from the inside, because reading a topic produces the same feeling of familiarity that knowing it does.

// RTL 9 - read is not rehearsed.
//
// Revision coverage is usually measured in topics read, and the number that
// predicts an interview is topics SAID OUT LOUD. The gap between them is
// invisible from the inside, because reading a topic produces the same feeling
// of familiarity that knowing it does.
//
//   BAD  : count the topics you have been through
//   GOOD : count the topics you have explained, unprompted, to the wall
//
// TEACHING MODEL.
module revision_coverage #(parameter int READING_COUNTS = 0) (
  input  logic clk, rst_n,
  input  logic        assess,
  input  logic [7:0]  topics_total, topics_read, topics_rehearsed,
  output logic [15:0] read_pct, ready_pct, reported_pct,
  output logic [7:0]  gap, n_assessments, n_overstated,
  output logic        prep_err
);
  logic [31:0] r_q, y_q;
  logic [7:0]  read_c, reh_c;

  // Neither figure can exceed the total.
  assign read_c = (topics_read > topics_total) ? topics_total : topics_read;
  assign reh_c  = (topics_rehearsed > topics_total) ? topics_total : topics_rehearsed;
  assign gap    = (read_c > reh_c) ? (read_c - reh_c) : 8'd0;

  assign r_q = (topics_total == 8'd0) ? 32'd0
             : (({24'd0, read_c} * 32'd100) / {24'd0, topics_total});
  assign y_q = (topics_total == 8'd0) ? 32'd0
             : (({24'd0, reh_c} * 32'd100) / {24'd0, topics_total});
  assign read_pct  = r_q[15:0];
  assign ready_pct = y_q[15:0];
  // The whole review point: which number the revision reports to itself.
  assign reported_pct = (READING_COUNTS != 0) ? read_pct : ready_pct;
  assign prep_err = assess && (reported_pct > ready_pct);

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_assessments <= 8'd0; n_overstated <= 8'd0;
    end else if (assess) begin
      n_assessments <= n_assessments + 8'd1;
      if (reported_pct > ready_pct) n_overstated <= n_overstated + 8'd1;
    end
  end
endmodule

The measurement. Twenty topics, eighteen read, six rehearsed:

20 topics, 18 read, 6 rehearsed : read=90% ready=30% reported=90%

Ninety percent against thirty. The reading-counts build reports 90, which is a true number about the wrong quantity — and it is the number almost every candidate has in their head the night before.

Evidence to demand of yourself. Two counts, kept separately. Read and rehearsed, and the gap between them as a number.

What escapes. Arriving at an interview believing you are at 90 percent when you are at 30, and discovering the difference in the room.

How to rehearse it. Keep the two lists. The drill is not more reading; it is moving entries from one list to the other, and that is the only revision activity in this chapter with a measurable output.

15. The Review Assembled

Nine dimensions, one summary — and the same trap this module has found at every level.

// RTL 10 - an interview review assembled. Nine revision dimensions, one
// summary. "I have been through the material" is bit 0: the pages were turned,
// and one sixth of a preparation.
module ivw_review_signoff #(parameter int READ_IT_IS_PROOF = 0) (
  input  logic clk, rst_n,
  input  logic        review,
  input  logic        material_read, can_derive, mechanism_named,
  input  logic        boundary_stated, both_sides_named, rehearsed_aloud,
  output logic [5:0]  fail_mask,
  output logic [15:0] conditions_met, sound_pct,
  output logic        sound,
  output logic [7:0]  n_reviews, n_sound, n_claimed,
  output logic        ivw_err
);
  logic [31:0] s_q;
  logic        truly_sound, claimed;
  assign fail_mask[0] = ~material_read;
  assign fail_mask[1] = ~can_derive;
  assign fail_mask[2] = ~mechanism_named;
  assign fail_mask[3] = ~boundary_stated;
  assign fail_mask[4] = ~both_sides_named;
  assign fail_mask[5] = ~rehearsed_aloud;
  assign conditions_met = {15'd0, material_read} + {15'd0, can_derive}
                        + {15'd0, mechanism_named} + {15'd0, boundary_stated}
                        + {15'd0, both_sides_named} + {15'd0, rehearsed_aloud};
  assign s_q = ({16'd0, conditions_met} * 32'd100) / 32'd6;
  // No clamp: six one-bit values over six cannot exceed a hundred.
  assign sound_pct = s_q[15:0];
  assign truly_sound = (fail_mask == 6'd0);
  assign claimed = (READ_IT_IS_PROOF != 0) ? material_read : truly_sound;
  assign sound = claimed;
  assign ivw_err = review && !truly_sound && claimed;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_reviews <= 8'd0; n_sound <= 8'd0; n_claimed <= 8'd0;
    end else if (review) begin
      n_reviews <= n_reviews + 8'd1;
      if (truly_sound) n_sound <= n_sound + 8'd1;
      if (claimed)     n_claimed <= n_claimed + 8'd1;
    end
  end
endmodule

The measurement. Two views of the same preparation:

never rehearsed aloud : mask=100000 met=5 sound=83%
I have been through the material : mask=111110 met=1 sound=16%

The first line is real preparation with one item open — bit 5, nothing has been said out loud. Five of six, and the remaining item is the cheapest of the six to close.

The second line is what this chapter exists to prevent. Bit 0 is clear and everything else is set: the pages were turned, and nothing can be derived, no mechanism can be named, no boundary can be stated, no cost can be given, and none of it has been spoken. Sixteen percent of a preparation, and it is the state that feels most like being ready.

Figure 3 — bit 0 is the one that feels like all six. Each of the other five has a test you can run in under five minutes per topic, with the page closed, and each produces a yes or a no rather than a feeling.

16. Quantitative Reasoning

Every figure here is a teaching parameter or a value derived from one and asserted by the testbench. None is a measurement of a real system, and none is a CXL specification number.

Depth, derived. Level 1 of 3 is 33 percent of what the topic can be taken to, and the two steps above it are both free of new reading. Reading raises the level by exactly one and cannot raise it further, which is why more reading is the wrong response to feeling unprepared.

Mechanism parts. Three parts — structure, event, failure — and two of three is a definition. The general form: parts named must equal 3, and the part most often missing is the third, because it is the only one that cannot be lifted from a page.

Follow-up depth. An answer surviving one question of three is at depth 1. A build judging on the first answer alone is indistinguishable from a genuinely deep answer for as long as nobody asks a second question, which is a statement about most practice sessions rather than about most interviews.

Derivation against recall, derived. At 20 outstanding slots over a 50-cycle round trip the rate is 20 x 100 / 50 = 40 units per hundred cycles. Double the slots to 40 and the derivation gives 40 x 100 / 50 = 80; the memorised figure still gives 40, which is now 50 percent of the right answer. Both answers were correct one sentence earlier, and the parameter change costs the interviewer nothing.

Claim boundaries. A claim with a boundary at 50, stated at an operating point of 80, is false — and the bounded statement is true at every operating point, including this one, because it carries the condition with it. The unbounded claim has exactly one operating region where it is safe and no way to say which.

Trade-off parts. Three parts — gain, cost, crossover — and two of three is not yet actionable. The middle case is a full third of the reachable states of that condition, and it is the state the first campaign here never drove.

Three whys. Level 2 of 3 is 67 percent, and it is the most common state of a well-prepared candidate. The third level is a constraint, and constraints are what separate a good interview from a decisive one.

The cost of a guess, derived. An admitted gap with a method costs 0. An admitted gap alone costs 1. A confident wrong answer costs 3 — three times the admitted gap, and the cost is not paid once but spread across every other answer, because the interviewer must now re-weigh all of them.

Revision coverage, derived. Twenty topics with eighteen read is 18 x 100 / 20 = 90 percent. Six rehearsed is 6 x 100 / 20 = 30 percent. The gap is 12 topics, and the reported figure differs from the real one by 60 percentage points — the largest single overstatement in this chapter, produced by counting the wrong quantity rather than by counting wrongly.

The sign-off arithmetic. Six conditions; five met is 5 x 100 / 6 = 83 percent under integer division, and one met is 100 / 6 = 16 percent.

17. Verification Method

Order of work

compile → inspect warnings → legal baseline → reset → boundaries → simultaneous events → abuse and error cases → configuration contrasts → structural gates → PASS → mutation campaign

A mutation campaign on a failing baseline is invalid, and the campaign in this chapter ran against a green one. The baseline was re-run after every testbench modification before the campaign was re-run.

Independent oracles

chkv prints got against expected, which is what lets an oracle be wrong out loud. In this chapter it caught none, and section 18 explains why that is a fact about the models rather than about the care taken.

X and Z rejected explicitly

chk(c, …) tests c !== 1'b1, so an X-valued condition fails rather than passing. chkv(got, exp, …) reduces the result and reports an explicit X/Z failure before comparing. 30.7 owes three undriven outputs to that rejection, and the same sweep was run over these ten models with no findings.

Pulses are latched, never sampled

Every evidence output — rec_err, defn_err, follow_err, wb_err, bound_err, trade_err, depth_err, trust_err, prep_err, ivw_err — is caught by a continuous always @(posedge clk) monitor into a sticky bit, asserted outside any conditional, in a window containing a clock edge.

Stimulus never lands on the active edge, and reset is released after it

step_clk is @(posedge clk); #1;, and reset release lands one delta after the edge. Carried forward from the race 30.5 exposed.

Both builds are always instantiated

Every model has both its honest and its shortcut build wired to the same stimulus. In eight of the ten, the shortcut build computes the honest figure internally and reports a different one — the difference under review is never the information available, always which number is believed.

Safety, liveness and performance kept apart

Safety-of-claim is this chapter's safety class. A topic is never reported ready above the level it reached. A definition is never accepted as a mechanism. A percentage reported is never above the rehearsed percentage. None requires an assumption.

Liveness — nothing in this chapter is a liveness claim.

Performance — nothing here is a performance claim. Every figure is a proportion of a target, not a rate.

18. Baseline Defects Found Before Mutation

RTL defects — none. Testbench defects — none. Wrong oracles — none.

This is the first chapter in the batch with a clean first run, and the reason is worth stating rather than celebrating.

The models here are combinational scoring of a handful of booleans, with two small registered counters each. There are almost no timing relationships to get wrong — and every wrong oracle in 30.5, 30.6 and 30.7 was a timing relationship: a counter read before its edge, a stamp taken before a step, a window that had advanced further than the stimulus lines suggested.

The lesson generalises the other way. Most oracle errors are not arithmetic errors; they are "when" errors, and a model with little state produces few of them. A clean first run on a combinational model is evidence about the model's shape, not about the author's care.

Both facts are recorded with the caveat 30.7 earned: a green first run is evidence about the tests that existed at that moment, not about the models. The undriven-output sweep and the structural gates were run separately, and the mutation campaign is what actually probed the models — and it found something the first run did not.

Coverage gaps found by the structural gates

The splitcheck hit is the same shape 30.3 found, and it is now a standing habit. One wrong answer out of two asked is a state an inverted counter reaches by the same total: the correct counter counts one wrong of two, and the inverted one counts one right of two. When a sub-count is exactly half its total, add one more case in either direction before the campaign runs.

Compiler-warning findings

Under -Wall the ten models produce no truncation, select-width, signedness, cast, multiplication-width, shift-width or loop-width warnings. The only warning is a missing timescale on models with no delay constructs — inspected and recorded as benign.

One width result was reasoned rather than trusted. The revision-coverage model computes two percentages from 8-bit counts scaled by 100, which reaches 25,500 at most and is assigned to 16-bit nets — comfortably inside, counted by hand rather than inferred from the tool's silence.

Simulator constraints

Icarus Verilog 13.0 rejects ref task arguments, carried forward from every chapter in this module.

19. Mutation Testing

65 mutations attempted, 65 non-equivalent, 65 killed. Zero unexplained survivors, zero equivalent mutants withdrawn.

Sixty-four of sixty-five on the first run is the highest first-run kill rate in the batch, and the single survivor is the chapter's own subject.

The one survivor: the middle of a three-part condition

The mutation dropped the crossover from the trade-off test — gain && cost && crossover became gain && cost. It survived because the stimulus drove a one-sided answer and a complete one and nothing in between.

Classified before anything was changed: a stimulus gap, not an equivalent mutant. The separating input exists — an answer naming the gain and the cost and not the crossover — and it was never driven.

The gap is exactly the shape of revision the review item is about. A candidate who can state both sides of every trade-off and cannot say when to pick which has done most of the work and stopped one step short, and the testbench had made the same omission about its own subject.

The habit that prevents it generalises beyond this chapter:

For a condition with N parts, drive all N cases with exactly one part missing — not just none-missing and all-missing.

This is the boundary family in its conjunctive form. 30.5, 30.6 and 30.7 produced eighteen survivors between them from a boundary the stimulus approached and never landed on; this one is the same failure applied to a logical condition rather than to a numeric comparison. The stimulus went from one to three and never stopped at two.

The classification rule

Never add an assertion for a survivor before classifying it.

20. Synthesis And Implementation Reality

These models are not meant to be synthesised, and saying so plainly is part of the source discipline this chapter is subject to. What follows is the honest reading of what they would cost, because "it would be expensive" is an argument that gets made about instrumentation and it is worth knowing when it is true.

Every scoring model here is a handful of gates. A three-part conjunction is a three-input AND. A parts-named count is a two-bit adder over three one-bit inputs. The entire chapter, as hardware, is smaller than one entry of any queue in 30.6.

The two percentage models are the only arithmetic of any size. A multiply by 100 and a divide by a runtime value is a genuine divider — the one structure in this chapter that would not be free — and in a real design it would be replaced by publishing the numerator and denominator and letting the reader divide. That is the same conclusion 30.5 reached about every ratio, arrived at here from the cost side rather than from the honesty side.

The registered counters are two per model. At 8 bits that is 16 flops each, 160 across the chapter. Counters are how a boolean property becomes reviewable over time, and they are the reason these models can be mutated at all: a purely combinational scorer has no history for a mutation to disturb.

The dual-build structure costs exactly double. Both the honest and the shortcut build are instantiated in every experiment, against the same stimulus. That is a verification cost, not a design cost — no shipped design instantiates two versions of itself — and it is what makes "the information was available and the conclusion differed" checkable rather than asserted.

No area, frequency or power figures appear in this chapter, because none was measured and none would mean anything if it had been.

21. Silicon Observability

No silicon publishes any of these. The section exists because the reasoning transfers, and because the analogue is genuinely useful.

The one that matters most is the first, and it is the same finding as 30.5 section 7: a ratio with no stated denominator is not a measurement. Ninety percent read and thirty percent rehearsed are both true of the same twenty topics, and only one of them predicts anything.

The second is the one with the sharpest edge. A confident wrong answer is the only item in this chapter whose cost is not local — it changes how every other answer is weighed, which is exactly the property that makes a permanently-zero counter the right instrument for it in hardware too.

Three of these are the same lesson in three domains: a number is only evidence when the quantity it counts is stated. That is 30.5's denominator, 30.6's effective-value register, and this chapter's two lists.

22. DebugLabs

These labs debug a preparation, using the same structure the rest of the module uses to debug a design. The symptom is an interview that went worse than expected, and the root cause is always a state that felt identical to the one above it.

Lab 1 — Every topic was familiar and none could be built

Symptom. An interview where every question was recognisable and the answers thinned immediately.

Evidence. Preparation consisted of reading, and it felt thorough throughout.

Hypothesis. Reading terminates at recognition.

Investigation. Close the book and explain three topics aloud. Two do not start.

Root cause. Level 1 across the board, with a level-3 feeling.

Fix. Read, close, explain, reopen, check. The reopen is the measurement.

Prevention. Never count a topic as covered until it has been explained with the page closed.

Observability. The two lists — read and rehearsed. The gap is the whole diagnosis.

Lab 2 — The first answer landed and the follow-up did not

Symptom. Strong opening answers, visible thinning on the second question, repeatedly.

Evidence. Each topic was rehearsed once.

Hypothesis. The rehearsal covered exactly the question that was rehearsed.

Investigation. For three prepared answers, write the obvious follow-up. None has an answer ready.

Root cause. Depth 1 preparation against depth 3 questioning.

Fix. For each answer, write the two questions you would least like to be asked, and answer them.

Prevention. Rehearse to depth 3 or record the topic as depth 1. A depth-1 topic is not an error; believing it is depth 3 is.

Observability. Depth reached per topic, written down.

Lab 3 — The number was right until the interviewer changed one input

Symptom. A figure quoted correctly, then a changed parameter, then nothing.

Evidence. The figure was memorised from a table.

Hypothesis. There is no relationship behind the number.

Investigation. Ask what the figure depends on. The answer is a page reference.

Root cause. A recalled number rather than a derived one. Worth exactly one question.

Fix. Write the expression, change an input, recompute.

Prevention. For every number in your preparation, the expression that produces it. Two minutes per figure.

Observability. The list of figures, each with its relationship beside it. A blank in that column is a fact rather than a family.

Lab 4 — A confident statement met a counter-example

Symptom. A general claim, a specific counter-example from the interviewer, and a conversation that did not recover.

Evidence. The claim was stated without conditions.

Hypothesis. The claim was absorbed rather than reasoned, so its boundary was never located.

Investigation. Ask where the claim stops being true. There is no answer.

Root cause. An unbounded claim. The easiest thing in an interview to disprove, and the disproof is remembered.

Fix. Three clauses: where it holds, where it reverses, roughly where the crossover is.

Prevention. For every claim in your preparation, write the case where it is false. If you cannot find one, you have not understood it.

Observability. Claims with their boundaries, as a list. A claim with no boundary column is a slogan.

Lab 5 — Both sides were named and the question stayed open

Symptom. A trade-off answer that named the gain and the cost, and an interviewer who had to ask which one wins.

Evidence. The answer was balanced and stopped there.

Hypothesis. The crossover was never located.

Investigation. Ask at which operating point the answer flips. There is no number.

Root cause. Two parts of three. The crossover is where the trade-off becomes actionable.

Fix. For each choice, the operating point where the answer changes — even approximately.

Prevention. A trade-off with no crossover is two facts. This is the case the first mutation campaign in this chapter also missed, which is recorded in section 19.

Observability. The crossover column. It is the one most often blank.

Lab 6 — The what and the how were solid and the why was not asked twice

Symptom. Answers that were correct, complete, and did not distinguish the candidate.

Evidence. Every topic was prepared to the level of what it does and how it does it.

Hypothesis. No topic reached its constraint.

Investigation. Ask why a third time on any topic. The answers run out.

Root cause. Level 2 of 3 — the most common state of a well-prepared candidate, and the one that produces a good interview rather than a decisive one.

Fix. Ask why twice more than feels necessary, on every topic.

Prevention. The third answer is almost always a constraint — a cost, a physical limit, a compatibility requirement — and constraints are what interviews are about.

Observability. Level reached per topic. A column of 2s is a specific, fixable finding.

Lab 7 — One invented answer undid eight good ones

Symptom. A strong interview with a disappointing outcome.

Evidence. One question was answered confidently and wrongly.

Hypothesis. The wrong answer changed how the other eight were weighed.

Investigation. Count the cost. An admitted gap costs one question; a confident wrong answer costs three, and the cost is not local.

Root cause. No rehearsed response for not knowing, so the reflex was to answer.

Fix. Rehearse the sentence. It ends with how you would find out.

Prevention. A permanently-zero counter: confident wrong answers. Any non-zero value is worth investigating afterwards.

Observability. The count, and the questions it happened on.

Lab 8 — Ninety percent prepared, thirty percent ready

Symptom. Arriving confident and performing well below expectation.

Evidence. Eighteen of twenty topics had been read the week before.

Hypothesis. The confident number counts the wrong quantity.

Investigation. Count topics said out loud. Six.

Root cause. Coverage measured in reading, which produces the same feeling of familiarity that knowing does.

Fix. Move entries from the read list to the rehearsed list. No new reading.

Prevention. Two counts, kept separately, from the first day of preparation.

Observability. Read and rehearsed as two numbers, and the gap between them as a third.

23. Coverage Reasoning

Coverage of your preparation has the same failure mode as coverage of a design: it measures what was reached, not whether anything was checked.

Four coverage models are worth keeping over a revision plan:

Depth coverage per topic. Bins on the level reached: 1, 2, 3. A plan with every topic at level 1 and full topic coverage is 100 percent covered and 33 percent prepared.

Follow-up coverage. A bin per topic on the depth of questioning it has survived. The cell that matters is depth 3, and it is the cell no amount of reading fills.

Condition-part coverage. For every three-part condition in your answers — structure/event/failure, gain/cost/crossover, what/how/why — three bins, each with exactly one part missing. Section 19 records the mutation that this model would have caught, on the testbench's own subject.

Spoken coverage. A cross of topic read against topic said aloud. The cell that predicts an interview is the intersection, and the read-only column is the one that produces the 90-percent feeling.

The bin the shortcut build cannot hit is the most valuable bin in any model. In section 6 it is "level below 3 reported as not ready". In section 13 it is "did not know, and said so". In section 14 it is "reported percentage below the read percentage". Each is unreachable in the shortcut build and trivial in the honest one.

24. How This Appears In Real Engineering

This chapter's subject is not confined to interviews, and the transfer is worth being explicit about, because every failure in it has a working equivalent.

Recognition mistaken for capability is why design reviews pass documents nobody could reconstruct. The reviewer recognises every term on the page, and recognition feels like understanding in a review exactly as it does in revision.

Definitions accepted as mechanisms is how a specification review passes a section that says what a feature is and not how it works. The follow-up that would find it is one question, and review meetings are short.

One-question-deep understanding is the normal state of a team that inherited a block. Everything works until the second question, which is usually asked by a bug.

Memorised numbers rather than derived ones is why performance discussions stall when a parameter changes. Somebody quotes a figure from a previous project and nobody can say what it depended on — which is 30.5's entire subject from the other end.

Unbounded claims are how architectural decisions get made from slogans. "Coherent attach is faster" has decided real architectures, and the crossover it does not mention is where the system actually operates.

Gain named and cost unnamed is what a proposal looks like when it is being sold rather than reviewed, and the cost surfaces during integration instead.

Two levels of why is the state of most documentation. What it does and how it does it are written down; the constraint that made it necessary is in somebody's head, and that person changes teams.

Confident wrong answers are expensive in reviews for the same reason they are expensive in interviews — they change how everything else in the document is weighed, and the re-weighting is not visible.

Read-not-rehearsed is why a team can have full documentation coverage and no ability to explain the system to a new hire. The pages exist and nobody has said the sentences.

25. Common Misconceptions

"I have been through the material." Then you are at level 1. Close the page and start the sentence.

"It looked familiar, so I knew it." Familiarity is what reading produces. It is the same feeling in both states, which is what makes it useless.

"I can explain it if I have the diagram." Then you can explain the diagram. The interview does not have one.

"That is the definition." A definition restates the term. A mechanism names a structure, an event, and a failure it prevents.

"I rehearsed that answer." To what depth? The second question is where rehearsal ends and understanding begins.

"I know the number." From where? A memorised figure is worth one question and does not survive a changed parameter.

"X is faster than Y." Where does that stop being true? An unbounded claim is the easiest thing in an interview to disprove.

"It gives you a single address space." And costs what? An answer that names only the gain is selling.

"I named both sides." And which one wins, at what operating point? A trade-off with no crossover is two facts.

"I understand why it exists." Why does the reason exist? The third why is where the constraint is.

"I should never say I do not know." A confident wrong answer costs three times an admitted gap, and the cost is spread across every other answer you gave.

"I am ninety percent through." Through reading. How many have you said out loud?

"I have read it." That is bit 0, and it is worth one sixth of a preparation.

26. The Checklist Applied To One Topic

The items above are abstract until they are run on something, so here is the whole checklist applied to a single topic from earlier in this track — coherent attach — with the page closed.

Item 1 — recognised, recalled or derived

Can I rebuild what coherent attach is from something more basic? The more basic thing is the memory system's ownership rules: a line has an owner, a writer must be the owner, and a reader must not see a copy the owner has already invalidated. Coherent attach is a device participating in those rules rather than being outside them.

If that sentence would not have come out, the topic is at level 1 whatever the reading log says.

Item 2 — mechanism, not definition

Three sentences. The third is the one that turns the first two into an explanation.

Item 3 — depth three

Q1: what is coherent attach? — the answer above. Q2: what does it cost? — a lookup on the access path, and a wait for it. Q3: why is it not universal, then? — because for a device that shares almost nothing, that cost is paid on every access and buys nothing. The third answer is a constraint, which is where section 12 says it should be.

Item 4 — derive rather than recall

What sustained rate can a requester achieve? Outstanding transactions divided by round-trip time, bounded above by the link rate. That relationship generates an answer for any parameters the interviewer names, and it is the 30.5 relationship rather than a figure from anywhere.

Item 5 — the boundary

"Coherent attach is better" — where does that stop being true? Below roughly a third sharing in 31.1's illustrative model, the simpler attach wins. The crossover exists, and naming it is the item.

Item 6 — both sides, and the crossover

Gain: correctness nobody writes by hand. Cost: a lookup on every access. Crossover: the sharing fraction at which the two are equal. Three clauses, and the third is the one usually missing.

Item 7 — the three whys, already done

Items 3 and 7 overlap deliberately. Depth-of-follow-up is about whether the answer holds under questioning; the three whys are about what the third answer reaches. An answer can survive three questions and never reach a constraint, which is the state a well-rehearsed candidate is in.

Item 8 — the honest gap

"How does the ownership state get looked up in a specific implementation?" — "I do not know the implementation. I would look at where the state is held, whether the lookup is on the critical path, and what happens on a miss." That is the rehearsed sentence, and it ends with a method.

Item 9 — said out loud

All of the above, spoken, once. If it has only been read, the topic is on the wrong list.

Running the nine items on one topic takes about ten minutes, and it produces a specific finding — a level, a missing part, a missing crossover — rather than a feeling. That is the entire claim of this chapter, demonstrated rather than asserted.

27. What Each Item Is Really Testing

The nine items are not nine independent skills. They fall into three groups, and knowing which group an item is in tells you what to do when it fails.

The three groups are ordered, and the order is why more reading rarely helps. A retrieval failure cannot be fixed by structure work, and a judgement failure cannot be reached until the structure exists. Diagnosing which group you are in is the difference between a productive evening and a long one.

The retrieval group is the only one where the fix is uncomfortable. Closing the page and failing to produce a sentence is unpleasant in a way that rereading is not, which is a complete explanation of why most revision is rereading.

The structure group is where the highest yield is. Writing three parts for a term takes two minutes and moves it permanently — and it is the only group whose output is a durable artefact rather than a state of your own memory.

The judgement group is what separates candidates who are otherwise equal. Two people can both explain a mechanism; one of them can say at which operating point the answer changes. That is section 10 and section 11, and it is what an interviewer is listening for once the basics are established.

One item belongs to no group. The honest gap is not a retrieval, structure or judgement item — it is a policy decision made in advance, and it is the only item in the chapter you can close completely in one minute by writing a sentence.

28. Interview And Design-Review Questions

These are questions to ask yourself with the page closed. Each one has an answer in this chapter, and the point of the exercise is to find out whether you can produce it rather than recognise it.

Depth and mechanism

1. Name the three states you can be in with a topic. Recognised, recalled, derived. Reading reaches the first and cannot reach the others.

2. Which one does an interview ask for? The third, because it is the only one that survives a question you did not prepare for.

3. How do you find out which state you are in? Close the page and say it out loud. The feeling is identical in all three states; the sentence is not.

4. What are the three parts of a mechanism? The structure that holds the information, the event that changes it, and the failure it prevents.

5. Which part is usually missing? The third. It is the only one that cannot be lifted from a page.

6. What distinguishes a definition from a mechanism in practice? One follow-up question. A definition has nowhere to go when you ask how it works, because it restated the term; a mechanism already carries the structure, the event and the failure, so the follow-up is answered before it is asked.

7. How deep should a prepared answer hold? Three questions. Most prepared answers hold one, because one is what was rehearsed.

8. Why is the interviewer's second question not adversarial? It is how they find the edge between what you built and what you memorised. Every candidate has that edge somewhere.

Numbers, claims and trade-offs

9. What is a memorised figure worth? One question. A derivation is worth every question in its family.

10. What does an interviewer do to tell them apart? Change one input mid-question. It costs them a sentence.

11. Twenty slots over a fifty-cycle round trip, in units per hundred cycles? Forty. Double the slots and it is eighty — and that second answer is the one that shows which state you are in.

12. Why name the boundary of a claim? Because naming it is what shows the claim was reasoned rather than absorbed — and because the alternative is being corrected at the boundary.

13. What are the three clauses of a bounded claim? Where it holds, where it reverses, and roughly where the crossover is.

14. Why is the unbounded version worse than saying less? It is the easiest thing to disprove, and the disproof is what gets remembered.

15. What are the three parts of a trade-off? The gain, the cost, and the crossover. The first two are facts about the options; only the third is a fact about the decision, which is why an answer that stops at two leaves the question open.

16. Which one makes it actionable? The crossover. Without it, the interviewer supplies the only part that decides anything.

17. Why is offering the cost unprompted worth so much? It is the cheapest available signal that you have shipped the thing rather than read about it. It costs one clause.

Depth of understanding

18. What does each of the three whys reach? What it does reaches memory. How it does it reaches the mechanism. What goes wrong without it reaches the constraint.

19. Which level is most candidates at? Two. It produces a good interview rather than a decisive one.

20. What is almost always at level three? A constraint — a cost, a physical limit, a compatibility requirement.

21. Why is that the level interviews are about? Because engineering is the management of constraints, and a solution understood without its constraint is a solution that cannot be adapted.

Not knowing, and coverage

22. Rank the three responses to a question you cannot answer. Confidently wrong is worst. Honestly unsure is acceptable. Honestly unsure with a method costs nothing.

23. Why does a confident wrong answer cost three times an admitted gap? Because the cost is not local. Every other answer must now be re-weighed.

24. What should your not-knowing sentence end with? How you would find out. That clause is what takes the cost from one question to zero — it turns a gap in knowledge into a demonstration of method, which is the thing being assessed anyway.

25. Why rehearse that sentence? Because the reflex under pressure is to answer, and a rehearsed alternative is what interrupts it.

26. What quantity does revision coverage usually count? Topics read. The quantity that predicts an interview is topics said out loud.

27. Twenty topics, eighteen read, six rehearsed. What are the two numbers? Ninety percent and thirty percent. The gap is twelve topics and sixty percentage points.

28. Why is that gap invisible from the inside? Because reading a topic produces the same feeling of familiarity that knowing it does.

29. What is the fix? Not more reading. Moving entries from one list to the other.

Method, and what this chapter shares with the rest of the module

30. What single condition makes a mutation campaign invalid? A failing baseline. Every mutation then fails for the reason the baseline does.

31. This chapter had a clean first run. What does that prove? That the models are combinational. Every wrong oracle in the preceding three chapters was a timing relationship, and these models have almost no timing.

32. Most oracle errors are what kind of error? "When" errors rather than arithmetic errors — a counter read before its edge, a stamp taken before a step, a window that had advanced further than the stimulus lines suggested. Fourteen of the fifteen wrong oracles in this batch were that shape.

33. The single mutation survivor here was what class? A stimulus gap: the middle of a three-part condition, never driven.

34. State the rule that kills that family. For a condition with N parts, drive all N cases with exactly one part missing.

35. How does that relate to the boundary family in the preceding chapters? It is the same failure in conjunctive form. There the stimulus went past a number; here it went from one part to three and never stopped at two.

36. What does splitcheck find, and why did it fire here? A counter whose inversion reaches the same total. One wrong answer of two asked is indistinguishable from one right of two.

37. What is the standing habit it produced? When a sub-count is exactly half its total, add a case in either direction before the campaign runs.

38. Why publish a numerator and denominator rather than a ratio? Because a ratio with no stated denominator is not a measurement — the same finding as the performance chapter, reached here from preparation.

39. Which counter in this chapter must read permanently zero? Confident wrong answers. Every other item here is a matter of degree — a level, a percentage, a depth — and this is the only one where any non-zero value costs more than it appears to.

40. Why is that the right instrument for it? Because its cost is non-local, which is exactly the property that makes a permanently-zero counter the right hardware instrument too.

41. What do these models score? A property of an answer. Not a person, and not a rubric — and every model header says so.

42. Why express preparation as booleans at all? Because a boolean can be mutated, and a mutable property can be tested. The value is entirely in the falsification.

43. What is the one structure here that would not be free in hardware? The divider in the two percentage models — which is why a real design publishes the two counts instead.

44. Name the failure this chapter shares with the integration chapter. A value reported that is not the value in force: an echoed intent rather than an effective configuration, and a read percentage rather than a rehearsed one.

45. Name the failure it shares with the debug chapter. Silence read as evidence. There it is a fault that stopped appearing; here it is a page that felt familiar.

46. What is the single question this chapter's review turns on? Could I rebuild this without the page? Every other item is a way of making that question answerable on a specific topic, and the question is only informative when the page is actually closed.

29. Exercises

1 — Self-assessment · Intermediate. Builds: making familiarity falsifiable. Take five topics from this module you believe you know. Bounded scope: for each, close the page, explain it aloud, then reopen and mark it recognised, recalled or derived. Report the distribution and say which single topic you would move up first and why. Hint: the reopen is the measurement — without it you are grading recall with the answer sheet closed.

2 — Design review · Intermediate. Builds: separating a definition from a mechanism. Take three terms you would use in an answer about coherency. Bounded scope: for each, write the structure, the event that changes it, and the failure it prevents — three sentences — and mark which of the three you could not write. Hint: the third is the one that cannot be lifted from a page.

3 — Self-assessment · Advanced. Builds: rehearsing to the depth interviews reach. Take one prepared answer. Bounded scope: write the two follow-up questions you would least like to be asked about it, answer both, and state which of the three answers is weakest. Hint: those two questions are the interview.

4 — Derivation · Advanced. Builds: converting a fact into a family of answers. List every number you would quote in an interview about interconnect performance. Bounded scope: for each, write the expression that produces it, name what it depends on, then change one input and recompute. Mark any figure for which you could not write an expression. Hint: a figure with no expression beside it is worth exactly one question.

5 — Design review · Advanced. Builds: locating the boundary of a claim. Take three general claims you would make about coherent attach, memory expansion or fabric topology. Bounded scope: for each, write where it holds, where it reverses, and roughly where the crossover is — then write the counter-example an interviewer would use. Hint: if you cannot construct a counter-example, either the claim is a tautology or you have not understood it.

6 — Trade-off · Advanced. Builds: making a trade-off actionable. Take two architectural choices from this module. Bounded scope: name the gain, the cost and the operating point where the answer flips, and say which of the three was hardest to produce. Hint: two of three is where most preparation stops, and the missing one is the same one every time.

7 — Self-assessment · Intermediate. Builds: measuring the quantity that predicts the outcome. Build the two lists for your own revision — topics read, and topics said out loud. Bounded scope: compute both percentages and the gap, then plan the next session as moves between lists rather than as new reading. Hint: the fix for a sixty-point gap is not more reading.

8 — Verification · Expert. Builds: testing a conjunction the way a campaign would. Take any three-part condition from your own preparation — structure/event/failure, gain/cost/crossover, what/how/why. Bounded scope: construct the three cases with exactly one part missing, say what each one feels like from the inside, and identify which of the three you would have skipped. Hint: this chapter's only mutation survivor was exactly this omission, made by the testbench, about its own subject.

30. Summary

Recognition, recall and derivation feel identical from the inside, and only the third survives a question you did not prepare for.

Reading raises a topic by exactly one level and cannot raise it further. Everything past level 1 requires the page to be closed.

A definition restates the term. A mechanism names a structure, an event that changes it, and a failure it prevents — and the third part is the one usually missing.

Most prepared answers are one question deep, because one question is what was rehearsed. The second is not adversarial; it is how the edge is found.

A memorised figure is worth one question. A derivation is worth every question in its family, and survives a parameter changed mid-sentence.

An unbounded claim is the easiest thing in an interview to disprove, and the disproof is what gets remembered. Where it holds, where it reverses, roughly where the crossover is.

An answer that names only the gain is selling. An answer that names the gain and the cost is two facts. The crossover is what makes it actionable.

The third why reaches the constraint, and constraints are what engineering interviews are about.

A confident wrong answer costs three times an admitted gap, and the cost is spread across every other answer you gave. Rehearse the sentence that ends with how you would find out.

Topics read and topics rehearsed are two different numbers, and the second is the one that predicts anything. The gap is invisible from the inside because reading feels like knowing.

Six conditions, and "I have read it" is one of them. Real preparation with one item open is 83 percent. Pages turned and nothing said aloud is 16.