Huh? Is the blood type really called “type O” in English? Because in German, it’s always been “Blutgruppe Null”, “blood type zero”.
Same in Spanish as @EinsteinsHund wrote for German: grupo sanguíneo 0 (cero), never O. I would call this if this is the case a very peculiar case of innumeracy. Anglophone innumeracy, so to speak.
This is, naturally enough, the English version. Summary: “It’s not that simple,” but it seems the English usage is the more official one, national variations notwithstanding. The article does not call the ‘Null’ usage wrong, but persists in using ‘O’. See also footnote [18], “Also sprach Landsteiner – Blood Group ‘O’ or Blood Group ‘NULL’”.
Americans say “O” instead of “zero” in a lot of situations.
True, but here we’re writing “O” instead of “zero”, which we don’t often do.
Isn’t it writing “O” instead of “0”, which often used to be the same character written or typed. It has drifted from it’s original meaning but that doesn’t make the matter any less clear for anyone.
Well, yeah. I guessed, though, that Pleonast wrote out the word “zero” to be more clearly distinguished from the single character numeral “0”, which could easily be confused with – or indeed could be identical to, in the case of older keyboards – the capital letter “0”. Seemed like a good idea to me, so I built upon it.
Which reminds me of another interesting fact. In the FORTH programming language, the names of functions, or “words” as they say, can be written with whatever characters you wish. You can name your function “2”, for example. There are occasional and perhaps pathological reasons why you might wish to do so, and renaming “2” to return 3, for example, is a most amusing thing to sneak into somebody else’s code.As a practical matter the language is very close to the metal, and nobody much is checking up on whether you should want to do what you did. For example, causing a hard crash is always a strategic option in FORTH programming.
For this reason I have occasionally given something a name like l|l|l|I|Il|, concocted of lowercase letter “L/l”, uppercase letter “I/i”, and pipe characters (the thing above the backslash which most people never use these days). It’s pretty difficult and time consuming to read names like this. Hint: it helps if you copy the name into a word processor file on multiple lines and put each line in a different font.
FORTH was the cleverest thing I had ever heard of, when I learned it about 40 years ago (though I have to say that object oriented programming and managed code today strike me as more clever still). It is versatile and flexible in the extreme. You can create your own FORTH environment with a few pages of text in the Microsoft Assembler, and then build on it in FORTH.
If for any reason you want to make a program hard to follow, you’d be hard pressed to find a more diabolical venue than FORTH.
Have you never heard of INTERCAL?
I was going to mention APL, but INTERCAL is even better, if you can actually manage to produce a working program in INTERCAL.
A friend of mine learned about INTERCAL ~25 years ago, and tried to write some programs in it (under Linux, I think). It hadn’t really been maintained, though, and didn’t work with the current C compiler at the time. He managed to fix whatever issues there were, and get it running. I think he went so far as to write a floating-point library for INTERCAL.
I haven’t heard from him in ages, so I don’t know if INTERCAL has faded into unmaintained status again since then.
No such discussion would be complete without:
I once had to access an electric meter over a phone for a tenant in a large office building, to acquire monthly electric usage (using a TI TTY no less!). The tech over the phone was carefully describing how to write the code, until I realized it was FORTH, which I had discovered some years before in Model Railroad magazine. Coding with the tech went much easier after that. Unfortunately I never really had any other use for it. It is a fun language.
My experience with FORTH was much better than most I’m sure. I worked with disciplined programmers who mostly stuck to a common set of well defined words and naming practices. FORTH allows great confusion, but it’s so low level that I wouldn’t count it in the class of what I refer to as ‘write-only’ languages that encourage obscurity and confusion.
While we’re on the subject, as part of my training I did a series of extra credit projects in IBM System/3 assembler. The language itself was pretty standard, except for the fact that data items were addressed by the rightmost byte; what made it … interesting … was that the System/3 had no floating point hardware, which made multiplication and division problematic. Multiplication wasn’t so bad, but division was a bear: keep subtracting while incrementing a counter until you couldn’t any more, then shift one over and start again.
The RTX2010 processor runs Forth natively, using a 256-line data stack and a 256-line call stack. It is very efficient, good for real-time code, and, being radiation-hardened, finds uses in thingies that go far away, including one that landed on a comet some while back.
Also, Forth is what runs the Open Firmware that has been used as startup code for a great many personal computing devices.
I don’t suppose there was any quick way to get the reciprocal of the divisor and multiply by that, without doing the same laborious division process to get the reciprocal? A lookup table maybe?
As long as the lookup table didn’t have any mistakes in it.
I know a Chinese woman who had this done as a teenager because her sweat was smelly and/or heavy by Chinese standards. However, she has significant scarring in her armpit region (decades later) which is not something I’ve noticed with Bruce Lee.
I suppose a lookup table might have been possible, but I’m not sure the language would have supported it (this was nigh unto 50 years ago). Another factor was that we could only do our test runs while CCP (a cutdown version of mainframe CICS) was down, meaning that everyone was locked out of the terminals. So we could only test during lunch and got at most two test runs a day, which brought the KISS principle into play.
Ah, the good old days 
.
I wrote a simple integer calculator in 6502 AL. To calculate a/b:
- set c =1, d = 0
- compare a - b, if positive, shift b left 1, shift c left 1, repeat until b’ is not less than a
- subtract b’ from a, if positive, add c’ to d, shift b right 1, shift c right 1, repeat until c = 0
result is in d, remainder is in a’
This process could be extended to arguments of any width and only requires as many subtraction cycles as the order of magnitude of a.