DATAOUT to DATAIN

The queue

The shift register has eight stages and a bit enters at one end. Clock in a ninth bit and something has to happen to the first one: it falls out of the far end, onto the pin printed (QH) DATAOUT.

Wire that pin to the next module's DATAIN and nothing is lost. It carries on into the next register, which is eight stages of exactly the same thing.

Watch the byte for the 7 land in the first module and then get pushed out of it by the byte for the 3. Two shiftOut calls and two modules are loaded; the first byte travelled twice as far as the second.

One latch for the whole row

Look at what the latch and clock do in that drawing: they go straight across the join, untouched, to every module at once. So does the logic rail, and so does the 12 V.

That is why the code for a chain is barely different from the code for one module:

void updateDisplay(const uint8_t *buf) {
  digitalWrite(LAT, LOW);
  for (int i = 0; i < NUM_DIGITS; i++)
    shiftOut(SER, CLK, MSBFIRST, buf[i]);
  digitalWrite(LAT, HIGH);
}

One more module is one more turn of the loop. The latch stays outside it, pulsed once, and every digit in the row changes at the same instant however many of them there are.

Plugging them together

The boards are meant to butt up against each other. Both edges have their seven holes in the same places, so two neighbours line up pin for pin across the seam, and a short length of the male header strip bridges them.

Turn that over and the two digits sit at their natural spacing with no gap between them, which is the point of joining at the edge rather than with flying leads.

How long can it get

Nothing in the protocol has a limit. Every extra module is one more shiftOut before the same single latch.

The real limits are ordinary ones. The 12 V supply has to carry every module in the chain, since they all draw through the join. And the wires between your microcontroller and the first module are carrying a clock, which is the one signal here that would rather be short.