Threading Signatures Forward with Pointers

The kettle stitch in Coptic binding does something clever: as you sew each new signature to the spine, you loop your thread under the stitch from the previous signature before pulling tight. This creates a chain. Each signature knows only about its immediate predecessor—there’s no central spine holding everything together, just a sequence of local connections propagating backward.

This is a linked list. Each node contains its own data and a reference to the next (or previous) node. No array index, no contiguous memory block—just a trail of pointers you follow until you hit nil.

Pascal made this explicit with its ^ pointer syntax. You allocate nodes dynamically with new, then wire them together:

program CopticChain;
type
  SigPtr = ^Signature;
  Signature = record
    hours: string;
    prev: SigPtr;
  end;
var
  current, node: SigPtr;
begin
  current := nil;
  new(node); node^.hours := 'Hrs 1-20';   node^.prev := current; current := node;
  new(node); node^.hours := 'Hrs 21-40';  node^.prev := current; current := node;
  new(node); node^.hours := 'Hrs 41-60';  node^.prev := current; current := node;
  while current <> nil do begin
    writeln(current^.hours);
    current := current^.prev;
  end;
end.

Output walks backward through the chain: Hrs 41-60, then Hrs 21-40, then Hrs 1-20. Just like flipping through a Coptic-bound logbook from the most recent signature toward the oldest.

R doesn’t have pointers, but environments are mutable reference objects—close enough:

sig <- function(hrs, prev = NULL) {
  e <- new.env()
  e$hours <- hrs
  e$prev <- prev
  e
}

chain <- sig("Hrs 41-60", sig("Hrs 21-40", sig("Hrs 1-20")))

cur <- chain
while (!is.null(cur)) {
  cat(cur$hours, "\n")
  cur <- cur$prev
}

Same traversal, same output. The syntax differs but the structure holds: each element carries a reference to the one that came before.

Linked lists fell out of fashion for most tasks—arrays are cache-friendly, random access is O(1), and memory allocation overhead adds up. But they remain the natural choice when you’re inserting or deleting at arbitrary points without reshuffling everything else. A logbook gains pages; you don’t reprint the whole thing.

What strikes me about Coptic binding is the structural honesty. The stitching is the spine. There’s no glue hiding the mechanism, no cover concealing how the pages hold together. Linked lists have that same transparency: the pointer is the structure. Follow the references and you understand the whole thing.