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.
– Peter Cordes
Jun 15 '21 at 09: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.
– Peter Cordes
Jun 15 '21 at 10:49
~ and HOME share a key, as do HJKL and the arrows keys.)
– ssokolow
Jun 16 '21 at 01:31
! was chosen in order to avoid confusion of competing character encoding standards wrt. ¦ (proposed programmers' ! in some standards) and ¬ (proposed programmers' ^).
– D. Kovács
Jun 16 '21 at 13:22
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.
! key, so it's easy to type - compare to APL symbols for which you need a specialized keyboard to use efficiently...
– Darrel Hoffman
Jun 15 '21 at 19:04
' for "not," MUMPS (which uses ! for "or") does this, and also allows you to prefix any operator that returns a boolean value, thus from > "greater than," ! "or," and [ "contains substring" can be derived '> "not greater than," '! "nor," and '[ "does not contain substring."
– A. R.
Jun 15 '21 at 19:23
!Y denotes the factorial of Y. And X!Y denotes the binomial coefficient "Y over X". Logical negation is ~Y there. I think it was at about that time that ~ was included in ASCII (while ! was there from 1963). Of course APL had and has many symbols which were not included in ASCII.
– Jeppe Stig Nielsen
Jun 15 '21 at 19:24
: for the ternary operator (along with ?). Not sure when it dates from in C though (the ternary operator originated with CPL ca. 1963).
– Alex Hajnal
Jun 15 '21 at 21:43
+-*/ already had well-established usage as arithmetic operators, <> for relationals, . as the decimal point, , for separating function arguments, and = for assignment. '" are used for quoting characters and strings. ()[]{} look weird if not used in pairs. Your answer rules out |%:;#^?. _ is ruled out by being allowed to start identifiers. \ is used for line continuation. & more intuitively represents an AND operation, rather than a NOT. That leaves !$@``~ as the only ASCII punctuation left.
– dan04
Jun 16 '21 at 00:12
' it is maybe worth noting that ! was originally ' overstruck with .
– Adám
Jun 16 '21 at 07:57
@ in email ('71) and the : in Smalltalk ('72) and C++ ('85). And some of the other examples, e.g. =/= wouldn't cause ambiguities in a lookahead (1) parser, since while there are multiple meanings of =, if you see a = followed by a /, there's only one legal parse that can follow from that.
– Ray
Jun 16 '21 at 16:10
~: 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.
– DrSheldon
Jun 16 '21 at 16:34
~= means approximately equal to in mathematic text. So probably would have added more confusion." MATLAB uses ~ for not and ~= for not equal. And MATLAB was designed by a mathematician. So I don't think this argument holds. @DrSheldon's argument seems more solid.
– Cris Luengo
Jun 16 '21 at 23:18
≠ (at least in the reference language). On KDF9 Algol prepared on a Flexowriter, that's equals overstruck with slash, but it's still a single 8-bit character on the disk.
– dave
Jun 17 '21 at 00:29
!n is the notation used for derangements in mathematics: https://en.wikipedia.org/wiki/Derangement
– phk
Jun 17 '21 at 06:04
¬ operator, or \`` on machines where it isn't available, whilst the ARexx dialect uses~` to the same effect. This answer is ahistorical and very far from a survey of what was established when C was first made.
– idrougge
Jun 17 '21 at 15:42
!=, maybe they simply chose it because they liked it better than <>. As for @, it is not "an abbreviation for a word" but is a graphic representation of the word at, which was very easy to write by hand. Modern typefaces have made it very stylized, as happened similarly to & over centuries from its origin et.
– Suncat2000
Jun 17 '21 at 15:54
! 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?
– blues
Jun 16 '21 at 06:51
. (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.
– dave
Jun 17 '21 at 01: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) – dan04 Jun 14 '21 at 18:16!is the factorial function. – ErikF Jun 14 '21 at 19:01/=or|=would also work as approximations of≠, but C uses those operators for other things. – dan04 Jun 14 '21 at 21:56=+,=/? – texdr.aft Jun 15 '21 at 02:44¬(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 :) – Dai Jun 15 '21 at 04:49|and¦? – dan04 Jun 15 '21 at 15:29| U+007C vertical lineand not¦ U+00A6 broken bar. But this may be a glitch in Ubuntu's keyboard layout. I ought to remap one to something more useful (and ¬ for that matter) – Chris H Jun 15 '21 at 15:34¬; not in my experience they didn't. My experience in the mid-70s was Flexowriters and Teletypes, and then imported DEC gear. In fact, I ran into no character set with¬in it, except for IBM gear. Maybe you had an ICL keyboard after the 2900 adopted EBCDIC? Can you elucidate? – dave Jun 15 '21 at 23:09-would have worked for logical negation. Did any language do that? – dave Jun 17 '21 at 02:48¦at 0x7C (broken bar) was to distinguish it from|(vertical line) as the alternative glyph at 0x21 (normally!(exclamation mark)), which was a concessions to 6-bit character set computers. Later ASCII changed that glyph assignment. Earlier IBM PC computers still had¦in its extended ASCII character set. – Eljay Jun 15 '22 at 14:15