The token XXX is frequently used in source code
comments as a way of marking some code as needing attention.
(Similar to a FIXME or TODO, though at
least to me XXX signals something far to the hacky
end of the spectrum, and perhaps even outright broken).

It's a bit of an odd and non-obvious string though, unlike
FIXME and TODO. Where did this
convention come from? I did a little bit of light software archaeology
to try to find out. To start with, my guesses in order were:

MIT (since it sometimes feels like that's the source of
90% of ancient hacker shibboleths)

Early Unix (probably the most influential codebase that's
ever existed)

Some kind of DEC thing (because really, all the world was
a PDP)

Other uses of XXX

It turns out that XXX and xxx are
incredibly annoying things to search for in old code. I'd bet it's
the most common sequence of 3+ identical letters in source code.
That means there's a ton of false positives to sift through.
Here's a few examples of the kind of stuff that will be found.

By far the most common use of XXX in old is for it to
be some kind of a template placeholder. This makes some sense;
x for an unknown value has an obvious long history
that predates computing. These templates might be used to describe
the exact data layout of something, like in the following bits from the
Apollo guidance computer:

Or as just a wildcard for a bunch of related names, like the in
this Lisp Machine source code:

;Q-FASL-xxxx refers to functions which load into the cold load, and
; return a "Q", i.e. a list of data-type and address-expression.
;M-FASL-xxxx refers to functions which load into Maclisp, and
; return a Lisp object.

Or as actual templates-as-program, with parts of
an input remains while others (those marked with XXX)
are programatically replaced. For example temporary file generation
in in UNIXv5:

f = ranname("/usr/lpd/dfxxx");

And finally, it could denote parts of persistent data structures
that were reserved for future use (or no longer used), for example
in CPM:

A less savoury use of XXX is as an identifier for
something that didn't even qualify to have a real name. Most
commonly it'd be the name of a branch target, like in a very
early version of the C compiler:

xxx:
if (o==KEYW) {
if (cval==EXTERN) {
o = symbol();
goto xxx;
}

It could also be used to name variables. The following is from the
FORTRAN II compiler for the IBM 704 from 1958. (I don't read 704
assembler, so maybe I'm misinterpreting what's going on in that
program. It seems funny enough that I wanted to include it here
anyway).

XXXXXX SYN 0 THE APPEARANCE OF THIS SYMBOL IN F4400370
REM THE LISTING INDICATES THAT ITS F4400380
REM VALUE IS SET BY THE PROGRAM. F4400390

Some DEC code seems to have gone really overboard with this, with
single source files having half a dozen different XXXYYY
identifiers. (Sorry, had to use YYY as the placeholder there for
obvious reasons).

Finally, there are all kinds of bizarre one-off uses. TENEX seems
to have used XXX for implementing rubout. That is,
when you'd press backspace to delete something you've typed, it'd
print out XXX on the teletype to mark the deletion. (Rather than
try to move the cursor back). Some kind proto-instant messaging
program from 1976 written in Interlisp that I found would just print
XXX as the error message for invalid user input.

Now, sorry if the above parts were kind of tedious. But there is
actually a point here. Turns out that XXX is
a really stupid marker to use for
a FIXME. Looking at the Panda TOPS-20 distribution,
there are 3083 instances of XXX, none of which are FIXMEs.
Just about anything else would be easier to
find. This makes its use as one of the three main
FIXME-markers all the more puzzling.

XXX as a FIXME

To get the negative results out of the way, there is absolutely no
sign of this being an MIT or DEC thing. XXX as FIXME
doesn't appear on ITS or TOPS-20 disks, nor does it appear in any of
the mountains of really old Lisp code that I happened to have around;
I don't think it makes it to Lisp-land until the mid-'80s. It's
also absent in smaller collections of old code from other sources.

I'm pretty sure these are not actually a FIXME.
It looks like the convention in this code was to mark
.de commands with three character tags depending
on their type, as explained in the beginning of the file:

+.\" Code on .de commands:
+.\" *** a user interface macro.
+.\" &&& a user interface macro which is redefined
+.\" when used to be the real thing.
+.\" $$$ a macro which may be redefined by the user
+.\" to provide variant functions.
+.\" --- an internal macro.

These lines seem to have been commands that didn't fit into
those existing categories, and needed a new tag.

Next up, there's a bunch of very promising looking changes to
the troff C source in the summer of 1980. Stuff like:

if(j == ' '){
storeword(i,width(i)); /* XXX */
continue;
}

That certainly looks like a classic FIXME. But I think
this is another dead end. It turns out that after this change there are
37 /* XXX */ comments in code that didn't use to have any.
And when comparing to Unix v7 source code, it looks like basically
every single line that was changed got marked with one. So it's
unlikely that these are actual FIXMEs. I think this
was just the author making sure they could identify their changes,
in case they wanted to reintegrate with "upstream".

Soon after that BSD moves to SCCS, and we start getting fine-grained
changes rather than huge code-dumps. From there, it's easy to find
the first /* XXX */ commit
from Nov 9, 1981. This one is interesting in a few ways:

This is definitely a FIXME; just a few very special
parts of the code got tagged, and many of them got rewritten soon
after.

After this commit, the use of /* XXX */ starts
spreading quickly through the BSD codebase and eventually to
other authors.

A closer reading of the commit shows something interesting:
a bunch of /* ### */ comments. Going through the earlier
history, it seems that Bill Joy had been marking
his FIXMEs with ###,
and halfway through this commit changed to using
XXX. I don't know why, or whether these two markers were
intended to have slightly different semantics (like ###
was code that needed to be fixed, XXX was code that
was commented out and needed to be fixed and re-enabled).
But XXX quickly became the preferred form.

(On a personal note, as someone who goes out of their way to read through any
published TCP stacks, I'm kind of amused that a search for a random
historical trivia leads me to a damn TCP stack).

Leaving it at that seems like a good story. And I'd already
checked basically all of Bell Labs code that I could find. It's not
in Unix v2-v7 and not in the Programmer's Workbench. But then I
decided to check Unix v1 just for completeness sake, and got very
confused. Because...

/ XXX fix me, I dont quite understand what to do here or
/ what is done in the similar code below e407:
/ cmp r5, u.count / see if theres enough room
/ bgt 1f
mov r5,u.count / read text+data into core

WTF? It doesn't get any clearer than that. But where did it come from?
And if this convention was used at
Bell Labs in 1970, where did XXX disappear for a
decade?

Turns out this was a false alarm. The only reason we have
the Unix v1 source code in the first place is that a team of people
transcribed the source from PDF scans to text. Then they went on to
make it possible to compile the code and run it in an emulator. As
part of this latter work, a block of code was added to the source.
And a bit unfortunately it was this patched version rather than the
"original" that made it to the Unix History Repo. This comment was
actually from 2008, not 1971.

There's actually an interesting story behind that extra block of
code, as told by Toomey. After finally getting the v1
kernel transcribed, compiled, and running, they hit the
problem of the only having two userland programs available:
init and sh. Everything else was using
a more recent executable header. To be able to do anything at all
with the system, they needed to add support for "0407 binaries" as
opposed to the "0405" ones the kernel supported natively.

What about C code outside of Unix distributions? It's actually kind
of hard to find any of that from before 1982.
There might be an earlier instance in Gosling Emacs, though it
differs from the modern form by going for a full 9 Xs:

And there's a Changelog entry from July 1981, which seems to match
up perfectly with both the functionality of the code, and the surrounding
ifdef:

Tue Jul 7 12:51:44 1981 James Gosling (jag at VLSI-Vax)
... I also installed Dave
Dyer's hack to allow ^G's to interrupt execution immediatly. This
has a rather major bug, and is the reason that I didn't implement
it a long time ago: if you type ^G while Emacs is doing output,
then all queued-but-not-printed characters get lost and Emacs no
longer has any idea of what the screen looks like. It is pretty
much impossible for Emacs to tell whether or not this has
happened. You end up having to type ^L now and then. The
"HalfBaked" switch in config.h controls the compilation of this
facility, ...

But thankfully this code has RCS history starting from 1986, and
somebody did in fact edit this code in 1986 with no functional changes,
but adding the commented out copy and the
XXXXXXXXX:

And those are the only signs of XXX in
applications that could predate the BSD usage. Both were
red herrings, caused by how difficult it's to actually find
pristine copies of source code that old. It was very lucky that
the Gosling Emacs comment was added after the code was put to RCS,
and made not in the five year interval between the original commit
and the project starting to use RCS.

So it seems likely that this convention was invented by Bill Joy
in BSD. If he wasn't the first one, he was certainly the one that
popularized it. Why he chose to switch to the rather inconvenient
XXX from ### is unclear.

If you can find an earlier occurence (or know of good collections
of pre-1981 C source code), please let me know and
I'll update the post.

Comments

Consider distress signals in morse code. XXX was considered urgent but less serious than SOS.

By Rich on 2017-04-17

I always felt like XXX was like the XXX on moonshine bottles indicating high potency.

By earnestly on 2017-04-17

Consider distress signals in morse code. XXX was considered urgent but less serious than SOS.

By Nick on 2017-05-18

Of course, "Why he chose to switch to the rather inconvenient XXX from ### is unclear" raises the question of how far back ### predates Joy's switch to XXX. Enquiring minds want to know, so all you've really done is created another archaeology task for yourself! (And, although not much of a coder myself, and not going that far back, I've always used ### to flag comments where there is code to reconsider or fix -- no idea of why/where I picked it up.)

By James Gregory on 2018-03-10

I'm fairly sure I started using XXX of my own accord without having seen it elsewhere. I also think, though I'm not 100% sure here, that maybe I used it in school essays several years before I even moved into software development.

My reason was that I'm lazy and the X key is near the shift key, making it easy to write 3 'X's.

By James Gregory on 2018-03-10

I'm now 100% sure, as I just found one of the early backups of a university philosophy dissertation, and it's filled with XXX all over the place.

By James Gregory on 2018-03-10

and also small 'xxx', so not to do with proximity with shift key but rather just something easy to type which stands out to the eye.