Retrocomputing Stack Exchange is a question and answer site for vintage-computer hobbyists interested in restoring, preserving, and using the classic computer and gaming systems of yesteryear. It only takes a minute to sign up.
Sign up to join this community
It seems that the use of the exclamation mark ! to denote negation started with the C programming language (as far as I can tell from my Google research). Nowhere though is mentioned who and why chose this symbol specifically, other than that it was simply available.
So, the question is: when, by whom, and why was ! chosen?
Since the few document trails on this topic quickly run cold, I contacted Ken Thompson. He confirmed that if there was anything he would have been influenced by at the time, it would have been BCPL and SMALGOL. But given that these don't use ! for negation, he "might have made it up".
I don't suspect there is anything more to it that can be researched.
The ! was around as part of the B programming language, according to the "User's Reference For B" (K Thompson, Jan 1972).
Somewhere between BCPL and B, the decision was made to use !.
In the Reference above, I can't find an indication of why it was chosen. "The NOT prefix unary operator ! takes an integer value operand. The result is zero if the operand is non-zero. The result is one if the operand is zero."
! belongs to the same group as || and && logical operators, which evaluate numeric operands according to != 0 being true. C's other negation operators are arithmetic - (value negation, subtract-from-0), and ~ (bitwise inverse, one's complement negation). Fun fact: on a 1's complement machine, unary - and ~ are the same thing, I think.
Jun 15, 2021 at 9:12
-0 would create a 0xffffffffU bit-pattern like ~0 would (which may be a trap representation on some 1's complement machines, so you'd want to implement signed int -x in a way that did 1's complement subtraction from 0, not just flipped the bits, on such a machine). I also wondered about signed-overflow UB, but now that I think about it, only 2's complement has a number whose negation isn't representable in the same type.
Jun 15, 2021 at 10:49
~ and HOME share a key, as do HJKL and the arrows keys.)
Likely because it's wasn't a widely used mathematical operator, and wasn't a quote symbol.
Other answers have pointed out that ! was used in B and then found its way into C.
The popular "not equals" operators in computer languages are:
!= → Probably meant to look like ≠. ! means factorial, but it's not an arithmetic operator. Most popular languages don't have a factorial operator, and on most non-trivial factorial operations like combinations and permutations there are algorithms that let you not do the full factorial math to solve them.
<> → < and > both have separate meanings in most languages, and < and > imply an order (i.e. something is greater than something else), which true and false don't really have.
=/= → The / already means divide, and /= means divide and save the results. It couldn't be used as a single character anyway, and a minor typo completely changes what it does.
'" (and back-ticks `) → The "not" symbol in math is usually the character written after the variable (so A'). It also indicates strings or characters, so it would have been confusing and likely difficult to parse. Back-ticks ` and ' look extremely similar so reading it would have been difficult. It's also pretty surprising how many programmers do not know what a back-tick is.
So out of all the ASCII symbols, ! is the one least likely to cause typos and confusion. It's on the wrong side of the variable to mean factorial, and even if someone was confused, a single run of the program would have shown them the error.
Some other choices and why they probably weren't in the running:
| - Already used to mean OR. Also, the pipe command, which was already used in Unix/Linux as a way to chain commands together, so probably not a good choice. People might have tried to chain functions together
% - Means modulo and percentage. Already widely used for something else.
: - Already used by labels and the ?: conditional shortcut. Looks really similar to ; which ended statements in C. Also was already used by Smalltalk and C++ for inheritance.
# - Part of preprocessor directives in C and used by many shells.
^ - Sometimes means "to the power of" in languages, so already taken.
? - Already a short-cut for if in many languages, and would imply you're asking a question instead of negation.
$ - Means money. Also heavily used by many shells to mean variable.
& - Means "and". Already used as a bitwise or logical AND in many languages.
~ - Not widely used in most programming languages, but ~= means "approximately equal to" in mathematical text. So probably would have added more confusion.
@ - Means "at". Not widely used in programming languages, but widely used in emails, which were invented in 1978. Not a good choice because it's an abbreviation for a word.
The comments are awesome. At first trying to pull some into the answer, but too many, and too many great history points.
: for the ternary operator (along with ?). Not sure when it dates from in C though (the ternary operator originated with CPL ca. 1963).
Jun 15, 2021 at 21:43
' it is maybe worth noting that ! was originally ' overstruck with .
~: The C bitwise operators were assigned before the logical operators. ~ was assigned to bitwise negation, being somewhat similar to the mathematical ¬ symbol. Therefore, ~ was unavailable later when the logical operators were created.
Jun 16, 2021 at 16:34
! as NOT surface?BCPL defined a number of logical operators, but these were all bitwise logical operators:
4.5 Logical Operators
[paraphrased: bitwise logical]
~ E1 (also not E1) or E1 & E2 or E1 \ E2
Some bitwise operators survived into B, particularly its AND (&) and OR (|) operators, whereas bitwise NOT did not. B introduced, however, the NOT unary prefix operator that was not a bitwise operator, but the integer logical NOT as we know it in C today:
4.2 Unary Operators
- The NOT prefix unary operator ! takes an integer rvalue operand. The result is zero if the operand is non-zero. The result is one if the operand is zero.
As this was a new operator not present in its predecessor BCPL, B had to make a decision as for what syntax to use for the operator. As this was moreover not to be confused with the bitwise NOT of BCPL, one might speculate that re-using ~ was not considered a good way forward. As for why ! was chosen given the (speculative) rejection of ~, another answer presents some good (albeit speculative) ideas.
!= or !?Finally, note that B also introduced the equality operators == (equal to) and != (not equal to), also not present in its predecessor, and it’s arguably
I always assumed we stole OR and NOT from propositional logic. It's roughly 15 years older than programming languages, and writes things like p|q and p & !q. Sure, they prefer the small 2-line right-then-down for a "not", but you can't type that; likewise the almost-V and upside-down V for OR and AND.
! that predates the programming usage?
. (or nothing) and +. AB+C is a lot shorter than A ∧ B ∨ C (though we knew that notation too) and the rules are the same as algebra. Negation (to the point of the current question) was an overbar in either notation.
Jun 17, 2021 at 1:33
I don't know if this has the logical ring to it that many in the computing community appreciate, but I can't get past an emotional interpretation:
"DON'T do that!" always has a "!" on the end of it. At least, it certainly did since childhood for me. Other examples: "No!" and "I told you, NO!".
There's a pretty strong negation in that character. It symbolizes alarm, that there's something wrong. I'd choose that character for negation.
Even now, whenever I see an exclamation mark, there is a sudden amygdalic spasm and a subconscious urge to pull back my hands and cover my mouth while I stare I what I shouldn't have been doing.
So where in a positive case, it might be == "yes, this", its != "no, NOT this!". i.e. Stop. ALARM Stop what? Stop 'this'.
Before I encountered coding (which isn't very much, btw) or logic (perhaps even less), I used to use "!" in handwritten notes for lab protocols ("caution", "error", etc, (but also, "activated") or as a shorthand for pain/physical injury in my training diaries.
I recall in my pre-computer days throughout my college math major courses (1968-1970), we were using the ! symbol in proofs as negative (meaning not). It appears that the use of the symbol "!" as "NOT" was not first begun with the use of the programming language C (which was one of several programming languages I later used), but was likely brought into C because of its use in logic and mathematic proofs. If we are looking for why it was used in C, that appears to provide a rationale. My school notes and textbooks are long gone, but there are some online links that support my memory: (1) https://stat.ethz.ch/R-manual/R-devel/library/base/html/Logic.html (2) https://en.m.wikipedia.org/wiki/List_of_logic_symbols
!as the array indexing operator. (The Development of the C Language)!is the factorial function./=or|=would also work as approximations of≠, but C uses those operators for other things.¬(and the broken-pipe symbol) - but the US keyboard doesn't - so methinks if K&R had a British keyboard for some reason then we'd be using better symbology all around, especially in C-derived languages today :)