Nothing Found

Open the UK Intellectual Property Office trade mark search. Type QXZVWRPLM. Press enter.

The page tells you no trade marks match your search criteria.

That is the right answer. Nobody has registered QXZVWRPLM.

Now type PHOENIX. A hundred and forty-six live UK trade marks come back. That is the register working: a question that should return nothing returns nothing, and a question that should return a great deal returns a great deal.

Last Sunday an agent I work with ran searches like these a different way, sending the terms as parameters in a URL rather than typing them into the form. The request never carried the search terms to the server. The page rendered its empty state and reported that nothing matched.

It did that for a word with hundreds of live marks standing behind it.

Two pages. One of them was the truth and one of them was a lie, and I could not tell you which was which by looking at them. They were the same page.

Abbey Road ends with a song called “The End.”

Then it stops. Then, twenty-three seconds later, Paul comes back for half a minute about Her Majesty, and it is not on the sleeve, and it is not in the track count, and for years plenty of people never heard it at all because they had already lifted the needle.

The sleeve was not lying on purpose. It printed what it printed. The truth was just somewhere the label did not go.

That is the whole essay, and I am going to spend the next ten minutes on a trade mark database, so hold on to the record: a page that says nothing found is a sleeve. Sometimes the record keeps going.

The only reason we caught it

We caught it because the agent searched for QXZVWRPLM first.

That was not intuition. It was an instruction I had written earlier the same day, for reasons that had nothing to do with this: run a query you know should fail before you trust a query that comes back empty. If both return the same thing, your instrument is broken and every result from it is worthless.

The nonsense string is the whole method. It costs one extra search. Without it, that page goes into a document as a clean result, and a clean result on a trade mark register is the kind of thing you print on a masthead.

I want to be precise about what failed, because the failure is narrower than it sounds and the narrowness is the interesting part. The register worked. The form worked. Type a word into the box, click the button, and you get real rows. What broke was one path into the same data, and the broken path produced output indistinguishable from the working one.

Nothing was wrong with the answer’s shape. It had the right heading, the right layout, the right confident sentence. It was well-formed and empty and wrong.

The same day, three more times

That Sunday produced three more of these before midnight.

A European trade mark tool applies class filters when the underlying office supports them. Where an office does not, the tool returns that office’s rows with the filter silently unapplied. This is documented behaviour, in its own help file. So a filtered result set is a mix of filtered and unfiltered rows, displayed identically. If you trust the filter you have no idea what you are looking at.

An agent reviewing seventeen trade mark records read the full text of six and skipped eleven, on the grounds that the owners were a standards body, a manufacturer, and some engineering firms. None of them looked like publishers. That is a judgment about names, not about registrations, and a registration is the only thing that decides what a mark covers. When we went back and read all eleven, one turned out to matter.

And then I lost a file.

An agent went to add a section to a document, used the wrong write mode, and replaced a hundred and ninety lines with the new section. The write succeeded. The tool reported success. There was nothing to recover from, because the directory was not under version control, and the only surviving copy was in another agent’s conversation history. We rebuilt it from there, word for word, and got lucky.

I want to tell you what that hour was actually like, because “we rebuilt it” is doing a lot of work in that sentence.

It is the feeling of reaching for a tape you know you left on the shelf. Not gone-in-a-fire gone. Gone like you have already looked twice and it is still not there and you are looking a third time anyway, because your hands do not believe it yet.

A hundred and ninety lines. Mine. Written that day. And the thing that ate them told me it had succeeded. Cheerfully. In green.

I got it back. That is not the part that stayed with me.

The part that stayed with me is that for about ninety seconds I believed I had not, and nothing on the screen had changed to tell me either way. Same window. Same confident little success message. The only thing that had moved was what was true.

Four failures in one day. Every one produced a well-formed output that looked exactly like the correct one.

What connects them

None of these were crashes. A crash is easy. A crash tells you it failed.

Each of these produced a plausible artifact. An empty results page. A filtered table. A reasoned decision to skip eleven records. A successful write. Each one was internally consistent, correctly shaped, and available for immediate use, and in each case the only way to discover the problem was to check it against something outside itself.

That is the part I keep coming back to. You cannot catch any of these by looking harder at the artifact. The artifact is fine. The artifact is beautiful. You need a second, independent path to the same truth, and you have to go and get it on purpose.

Every record shop has a bin of sealed reissues that sound wrong the second you drop the needle. Perfect sleeve. Perfect shrink. Bad pressing.

You cannot see it. You can only hear it, and only if you play it, and only if you know what it is supposed to sound like.

Why I am writing this down

Before I get to the professional version of this, here is where you already live in it, whether or not you have ever touched a database.

A pharmacy system says no allergies on file. Does that mean you do not have one, or that nobody typed it in?

Your bank says no transactions found for that date range. Quiet month, or broken filter?

You search a listings site for the job you actually do and get nothing back. Is nobody hiring, or did the search quietly drop a word?

Every one of those is the page I got. Well-formed, confident, and possibly a lie. And in every one of them the cost lands on the person who trusted it, never on the system that printed it.

That is the part that gets me. The machine is not embarrassed. It does not know. It hands you a clean page and moves on, and you are the one who walks out of the pharmacy.

I spend my working life on interfaces that have to serve two readers at once, a person using assistive technology and a machine acting on their behalf. The failure I described above is the failure that matters most in that work, and it took a trade mark database to make me say it plainly.

An aria-label that describes a button accurately is useful. An aria-label that describes what the button did last quarter is worse than no label at all, because a screen reader will read it with exactly the same confidence and the person listening has no way to know. A zero in a dashboard cell can mean the value is zero. It can also mean nobody measured. Those are different facts and most systems render them as the same character.

A person acting on a confident wrong answer is in a worse position than a person facing an obvious gap. The gap is honest. You can route around a gap. You cannot route around something that looks correct.

This is not a new observation. It is the oldest complaint in accessibility work, arriving in a new costume: the label is present, the markup validates, the checker passes, and the thing still does not work for the person using it. What Sunday gave me was four fresh examples from outside the field, where nobody was thinking about disability at all, and the same failure showed up anyway.

The practice, since a complaint without a practice is just a complaint

Run a query you know should fail.

That is the method. Before you believe an empty result, ask the system something absurd. If the absurd question and the real question produce the same answer, you have learned nothing from either, and you now know it.

The rest follows from taking that seriously:

Give a missing value its own state. Absent and unknown are different, and a system that renders them identically has thrown away the difference before anyone could act on it.

Say when the answer was last true. Freshness is not a nice-to-have on a declaration. A statement that was correct in March and is rendered without a date is a confident wrong answer waiting for someone to use it.

Put a name on it. Someone is responsible for the claim being true, and if no name appears, nobody is.

If you do not query databases for a living, the same move still works and it is smaller than it sounds.

Ask the thing a question you already know the answer to.

Before you trust a search, search for something you are certain is in there. Your own name. The prescription you know you are on. The transaction you made on Tuesday. If it comes back empty, you have just learned the instrument is broken, and you learned it for free, before it mattered.

That is the consumer version. One question you already know the answer to, asked on purpose, before you need it.

The re-run, which broke the practice

I went back to the register before publishing this, because the draft made a claim about a database, and a claim about a database is exactly the kind of thing this essay says you have to go and check.

Four things came back. Three of them changed the piece.

The first was that a number in my draft was wrong. I had written that the word I searched had more than six hundred live UK marks behind it. On 4 August I could not reproduce six hundred at any setting. Exact match returned forty-eight. Contains-word returned five hundred and forty-five. Two other settings refused to answer at all, on the grounds that there were more than a thousand results. The real number is somewhere in that spread and I cannot tell you where, because the answer depends entirely on a dropdown most people never touch. So the figure is gone. An essay about confident wrong numbers does not get to carry one.

The second was that the failure is worse than I described it. When I sent a search through the parameterised path this time, the page did not come back empty. It came back full. Five hundred and forty-five rows, real registration numbers, real filing dates, real classes, laid out exactly as a correct answer would be. They were the results of the previous search I had run in that browser. The parameters were ignored. The page served whatever was already in the session and showed me a web address that said something else.

An empty page at least looks like nothing. This looked like diligence.

The third is the one that cost me something. I sent QXZVWRPLM through the same parameterised path. It returned the same five hundred and forty-five rows.

Read that twice, because I had to. The control query came back looking exactly like a successful one. The method I spend the last third of this essay recommending does not catch this failure. It catches the empty-state version and sails straight past this one.

So the practice needs a second half.

Run a query you know should fail. Then run a query you know should succeed, and check that you got back the thing you asked for, not merely that you got back something. The first control tells you the instrument is alive. The second tells you it heard you. I had only ever written down the first, and I had written it down confidently, in a document about being careful.

The fourth thing was smaller and I am including it because it is the same shape. I filtered the register to live marks only. One of the rows it returned is marked expired. That may be correct, because a mark inside its restoration window is arguably still alive, or the filter may be leaking. I do not know which. The honest move is to say so rather than pick the reading that makes my table tidier.

The part I would rather not include

The file I lost was mine, in my own directory, on my own machine, and the reason it was unrecoverable was that I had never run git init in that folder.

I had spent that entire day writing rules for other people’s tools. Validate your instrument. Distinguish unknown from absent. Never trust a return code. Every one of those rules was in a document in the directory that had no version control, and I wrote them without noticing.

The agent that overwrote the file did something I would have called predictable if it had happened to anyone else. What made it unrecoverable was mine.

I am not telling you this for the confession. I am telling you because the gap between knowing the rule and running the rule is where all of this actually lives, and if I skipped that paragraph you would be entitled to assume I had never fallen into it.

And then I did it again, in this essay, in front of you. I wrote down a control query as though it were a complete method, and I published a number I had not re-derived. I only found out because I made myself go back and check my own homework before it went out the door.

Run both control queries. One that should fail, one that should succeed. They take twenty seconds between them, and they are the only reason I know any of this, including the part where I found out I had been recommending half a method.