For the winning team … if weather or riots etc suddenly prevent further we can declare no win or in some cases both win (each got 1 point instead of re-match).
And formal logic, and reletadly generally mathematical proofs.
In computer programming, "xor" is always used with the meaning "sum modulo 2", never with the meaning "exclusive or", despite its etymology.
The 2 logical functions "exclusive or" and "sum modulo 2" are distinct. They coincide only when applied to two arguments, but they are very different when applied to 3 or more arguments.
"Exclusive or" of N Boolean values is true when one and only one of them is true. "Sum modulo 2" of N Boolean values is true whenever an odd number of them are true.
Both logical functions are very important and I find annoying that the name of "exclusive or" has been misapplied to "sum modulo 2".
The confusion between their names has appeared only some time around 1950, when someone of the designers of the first computers, while implementing in hardware the parity function, a.k.a. modulo-2 sum function, has decided nonetheless to give it the XOR mnemonic from the different "exclusive or" function. and then many others have followed this usage.
It is OK now to use XOR, but one should always be well aware that XOR means parity a.k.a. modulo-2 sum, and not "exclusive or".
I have replied to the parent comment, where the computer mnemonic "xor" was used to mean "exclusive or" in natural language, which is not recommended, as it may be not clear which is the intended meaning, because "xor", in its normal usage, does not mean "exclusive or".
It should be noted that in mathematical notation, the 3 logical quantifiers "for all X ...", "there exists a X ..." and "there exists a unique X ..." correspond to the 3 logical functions "and", "or" and "exclusive or", and not to "and", "or" and "xor" (in the normal meaning of "xor").
The "real xor of >2 arguments" is more useful with a notation like exactly_one(a,b,c).
“To mean xor” isn’t really the best way to put it because “xor” in programming is often generalized to “odd parity”, ie xor(x,y,z) usually means x^y^z instead of x+y+z === 1. Does the second interpretation even have a common name to distinguish it from the odd parity interpretation of xor for multivalued cases?
Is it possible that, then, programmers were not familiar with dozens of other languages? I notice this about the R language (1993), a derivation of S (1976): it is like a language from an alternate timeline in which syntax settled on other conventions but, at the time, the question wasn't closed.
In those days people knew more programming languages than is common today. In addition most of the people on the CL committee were academics or from academic instititutions — “industry” back then was more nerd oriented than business oriented as it more commonly is today.
I started programming in 1981 and read a bunch of older sources in that decade, and saw IOR sometimes (I forget where).
I briefly read that five minutes ago and will probably remember it next week.
We can just about define the concept of a higher level language in terms of how it makes numerous chores and concerns implicit.
Good explicit could beat bad implicit in some situations, and vice versa.
That's not right. There is an explicit indication of where you want to go, the program counter. By default it will increment in an explicit, documented way, but you can also write directly to it. There's nothing implicit about it.
"Appearing as an operand" means that the instruction could choose a different register to increment other than the program counter, and to increment it by a different value other than exactly to the next instruction.
Indeed, if there is a program counter visible as a register, then it is an explicit representation of where execution is happening.
You don't seem to be sensitive to the IMHO critical difference between "explicit representation" and "explicit operation", though.
An explicit representation can be subject to the implicit effects of operations.
E.g. is is implicit that mkdir("foo", 0755) in Unix will create the directory entries "." and "..". Much of the time you don't worry about them. They are explicitly there, to be sure.
A closure object is an explicit representation of a function; the capture of lexical varaible values by a closure is implicit.
Specificity is the soul of narrative.