CoAgnes Labthe study spaceresearch preview · build 1ececa2

Reading aids · CoAgnes Lab

Questions the set answers

The questions a reader brings to the Nest Runtime Specification Set, volume by volume in the set's reading order — each one linked to the section whose own text answers it.

The questions are the Lab's reading aids, asked of the set, not part of it: the answer is always the volume's own text, and where a question and its section could be read differently, the section governs. Each volume's page carries its questions beside its sections too.

Introduction and Reading Map

  1. What is the Nest runtime, in one sentence? §1
  2. Must a conforming machine use a language model? §1
  3. Where must two implementations agree to be compatible? §1
  4. In what order should the volumes be read? §2.3
  5. What do CURRENT, DECLARED, PROPOSED and SEED mean? §3
  6. Which words mark a requirement? §4
  7. Where is each part of the machine specified? §6
  8. How does the set itself change? §7

Volume 01 — Overview: the Nest Runtime at a Glance

  1. What does the Nest runtime do, in one paragraph? §1
  2. How does it differ from a conventional processor? §1
  3. Which commitments shape the whole architecture? §2
  4. What does the circle-and-triangle figure show? §3
  5. What may a knot, a bind and a controller each do — and never do? §4
  6. What makes a machine deterministic, semantic or hybrid? §5
  7. What does a programme for the machine look like? §6
  8. What must hold for the machine's decoupled model to stay consistent? §7

Volume 02 — Machine Model and the Architectural Register File

  1. What does a Nest machine instance consist of? §1
  2. Where may the machine be asynchronous? §2
  3. What is each station required, allowed and forbidden to do? §3
  4. What is the complete state a machine holds between tuples? §4
  5. What happens to a knot's clews when its id is registered again? §4.2
  6. Can a programme read a register directly? §4.7
  7. How does a knot's readiness wake a bind descriptor? §5
  8. What must an engine written in another language preserve? §7

Volume 03 — The Wave Log: Envelope, Ordering, Persistence

  1. Who assigns a tuple's offset, and can it ever change? §1
  2. Can a new protocol add an envelope kind? §2
  3. Must an answer stand next to its cause on the log? §3
  4. How does an answer find the intention it answers? §4
  5. What does a key partition — the log, or the winding? §5
  6. Can a persisted log be fed back into a live engine? §6
  7. What is the difference between quiescent and settled? §7
  8. What makes the log grow, and where is retention handled? §8

Volume 04 — Tuple Reference

  1. How are unknown fields in a protocol payload treated? §1
  2. When does an invalid knot configuration fail — at registration or at first use? §2.1
  3. What does a readiness tuple carry, and when is it committed? §2.3
  4. What is published when an operator bind's gate fails? §3.2
  5. What happens to a clew when its winding intention fails? §4.4
  6. Which answers terminate a service intention's uid? §5.2
  7. Under which fact type is a service result published? §5.3
  8. May a shell commit a reserved-namespace fact, or a pipeline forge one? §6

Volume 05 — Activation Knots: the Accumulating Units

  1. Who commits a knot's readiness, and when is it evaluated? §1
  2. Can a knot become ready more than once? §1
  3. What is the difference between a knot definition and its clews? §2
  4. When does a collection rule accept a fact? §3
  5. Which conditions may a deterministic knot test? §4
  6. How does a semantic knot wind through the world? §5.2
  7. What happens to a clew when its winding intention fails? §5.3
  8. What happens when a clew exhausts its budget below its threshold? §6

Volume 06 — Bind Descriptors: Gather, Judge, Publish

  1. Through which channels does understanding enter a bind? §1
  2. How often does an emit descriptor publish? §2
  3. Which readiness tuples wake an operator bind? §3
  4. Must the demands be ready at the same moment for the barrier to be met? §4
  5. Can an operator bind project twice on the same key? §4
  6. What happens when a gate fails — can the bind try again? §5
  7. Who publishes an operator bind's result — the bind or the controller? §6
  8. In an unfold, what does the model supply, and what is fixed in advance? §7

Volume 07 — The Membrane and Output Controllers

  1. What is the membrane, and what crosses it? §1
  2. What must an output controller implement? §2
  3. What is the difference between an expected failure and a defect? §2
  4. Can an intention be discharged twice, or retried? §3
  5. When does the membrane sweep — during propagation, or after it? §3
  6. What does a controller publish when a service request is answered? §4.2
  7. Where do a controller's credentials live? §5
  8. What may a shell commit from outside, and what may it not? §6

Volume 08 — The Nest Virtual Machine: Assembly, Settle, Classes, States

  1. What is one machine instance assembled from? §1
  2. Do a product's CLI, workbench, chat and tests run the same machine? §1
  3. How does the runtime drive a wave to rest? §3
  4. What happens when several discharges are in flight at once? §3
  5. Does re-executing a run reproduce its log? §5
  6. In which states can a run end — and does ‘settled’ mean the answer is good? §7
  7. What may a shell show about a run? §8
  8. Can a machine continue a run from a reloaded log? §9

Volume 09 — Authoring Formats: YAML Grammar, Packages, Compilation

  1. What happens to an unknown key anywhere in a pipeline document? §2
  2. What does each value supplied for an input become at run start? §3
  3. Can a pipeline use a branch other than main? §4
  4. What does the compiler check in an unfold template before any run? §5.3
  5. Can a document with one error still register its valid records? §6
  6. Which JSON Schema keywords may a result contract use? §7
  7. Does the compiler check end-to-end reachability, from input to emit? §8
  8. May an implementation reinterpret a pipeline instead of rejecting it? §9

Volume 10 — Programming the Machine: Algorithmic Constructs

  1. What are the two moves every figure composes from? §1
  2. How does a figure branch, or loop, without a branch or loop construct? §1
  3. How does a figure wait until several named facts exist? §2
  4. How should a semantic cell's questions and threshold be chosen? §3
  5. Why are budgets mandatory on an understanding canvas? §4
  6. In an unfold, what does the answer decide, and what does the template fix? §6
  7. What can a guard do on the current rails, and what is its declared future form? §7
  8. What should be checked before running a new figure? §10

Volume 11 — Extension Points and the Widening Discipline

  1. May a new capability require the flat machine to change behaviour when it is absent? §1
  2. How does the invariant core itself change, and which widenings are on record? §2
  3. Can a wave fact install a new output controller? §3.4
  4. What must a new protocol family declare, and may it add an envelope kind? §3.6
  5. May an extension bring a condition language of its own? §4
  6. Can a pipeline use affinity heads, synthesis fan-in or terminal guards today? §5
  7. May an extension assume that a persisted log can be restored into a live engine? §6
  8. What must an extension specification state to conform? §7

Volume 12 — Extension Specification: Semantic Charters, Cells, CellSpace

  1. Is a Cell a security sandbox? §1
  2. Can the model that authors a blueprint widen the policy it runs under? §3
  3. Does every tuple on the log say which Cell it belongs to? §4
  4. Who assesses a Cell's result, and who computes the aggregate? §5.4
  5. When does a Cell's result become public? §5.5
  6. What happens when a package fails a single admission check? §6
  7. Which problems does the extension leave unsolved? §11
  8. What must an implementation demonstrate to claim the Cell extension? §13

Volume 13 — Extension Specification: Experience Protocols and Learning

  1. How does portable knowledge cross the product boundary? §1
  2. What does the seed describe first, and can a description disagree with prose? §2
  3. Where do large bodies of evidence live, and what does the log carry? §3
  4. Can guide text satisfy a knot that requires human.answer? §5
  5. Does the learning surface need a change to the machine's core? §5
  6. When does a chat message become truth? §6
  7. When is the seed viable? §7
  8. What does the seed leave open? §8

Volume 14 — Conformance, Compatibility, and the Seven Verification Matrices

  1. Which conformance class is sufficient for a trace tool, a digest service or a UI? §1
  2. When are two differing implementations compatible, and how is each surface tested? §2
  3. Does field order matter when a log is compared with the golden fixture? §2.1
  4. What does a run fed only the golden fixture's first message yield? §2.2
  5. Must a port translate the reference implementation's regression suite? §2.2
  6. Can a behaviour change land without its specification change? §3
  7. What happens to a matrix cell that has no demonstrable answer? §4.8
  8. What does non-conformance look like in practice? §5

Volume 15 — Terminology

  1. What is a clew, and how does it relate to its knot? §2
  2. Is readiness a state of the knot, or a tuple on the log? §3
  3. What is the difference between a head and a demand? §4
  4. How are a branch, a ledger, a plane and a level related? §5
  5. Is an output controller a knot, a bind, or something else? §6
  6. What does the bare word Nest name — the machine, or the workbench? §7
  7. Which things are called a template, and how are they told apart? §8
  8. Are Cell and Charter terms of the current machine? §9