What a front and back check proves

Presented with a nexus market url, or any long string, almost everyone does the same thing. They read the first several characters carefully, their eye skims the middle without registering it, and they land on the last few. Then they feel checked.

That feeling is the problem. The procedure is fast and it does catch some real failures, but the confidence it produces is out of all proportion to the ground it covers, and the tiles above put a number on the gap.

The first gauge assumes a front glance reads as far as the shared opening, which is 5 characters. That is generous in one direction and mean in another: some people read further, and many stop earlier because the shared opening is the part that feels most familiar and therefore gets the least attention.

The second tile adds a back glance of four characters and reports what is left in the middle: 47 characters that nobody looked at. Out of 56. The exact assumptions are arguable, and even under generous ones the answer is that most of the string goes unread.

It gets worse when you notice which part the habit covers. The front is the shared opening, which every address in the set carries and which anybody can reproduce. The back ends on a symbol fixed by the format, which every address of this generation carries.

So the front and back check spends its effort on the two regions of the string that are guaranteed to look right, and skips the 51 characters where all the identifying information actually lives. It is not a weak version of a good check. It is a check aimed at the wrong place.

It catches damage, and damage is common. A truncated paste, a string that lost its tail at a line wrap, a copy that picked up a stray character. All of that shows up at the ends, and the ends are exactly where a fast glance looks.

So the check is fine as a check for breakage. The mistake is treating it as a check for substitution. Those are different failures with different shapes, and the fast glance only sees one of them.

• Copy the address rather than reading it. This removes the question instead of answering it.
• If you are comparing two copies, compare a block from the middle. It is the part with information in it and the part nobody else checks.
• Pick your middle block by position, not by what catches your eye. Landmarks are where your attention already goes, so they are the parts you are least likely to be wrong about and least likely to be tested by.
• Accept that a partial check is partial. Knowing the size of the gap is worth more than closing a little of it.

If you are going to spend attention on a comparison at all, spend it in the middle. Pick a block by counting rather than by looking, compare it fully, then move to another block chosen the same way. Two blocks read properly from the middle are worth more than the whole front read carefully.

This runs against instinct, because the ends feel like the natural handles on a string. They are handles for finding it, not for checking it. Handles are the parts everybody grabs, which makes them the parts an imitation would get right first.

The other version worth the effort is the one where you do not read at all. Copy the string, paste it beside the one you already trust, and let the machine compare them. That covers all 56 positions in one action and does not degrade when you are tired.

Is a front and back check better than nothing?

Yes, for damage. It catches truncation and stray characters reliably, which is a real category of failure.

How much would I have to read for a real check?

All of it, position by position, against a source you already trust. There is no partial version that catches substitution.