Reading hexadecimal numbers out loud
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
Personally I think of it as 8H7 or 8 x 167 : similar to 8E7 for decimal is 8 x 107 But I don't know anyone else who does. :-D
Ideological Purity is no substitute for being able to stick your thumb down a pipe to stop the water
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
0x80000000: "Zero X Eight followed by seven zero's"0x8A2D35CB: "Zero X Eight A two D three five C B" And yes, I do pronounce the "0x". Since I do user interfaces, half the time I'm talking to users, and the other I'm talking to the yahoos I front for. Adding the "0x" prefix helps keep things unambiguous.Software Zen:
delete this; -
Personally I think of it as 8H7 or 8 x 167 : similar to 8E7 for decimal is 8 x 107 But I don't know anyone else who does. :-D
Ideological Purity is no substitute for being able to stick your thumb down a pipe to stop the water
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
I don't want large numbers pronounced. They may appear in log files and the like, I only trust them when I see them, preferably in electronic form. I see no point in people reading them as they will be wrong most of the time anyway. Source code should be pronounceable, so identifiers need to be close to real words; and magic numbers and error codes should be symbolic constants, not just a bunch of digits. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
I spell all the letters/numbers.
Watched code never compiles.
-
I don't want large numbers pronounced. They may appear in log files and the like, I only trust them when I see them, preferably in electronic form. I see no point in people reading them as they will be wrong most of the time anyway. Source code should be pronounceable, so identifiers need to be close to real words; and magic numbers and error codes should be symbolic constants, not just a bunch of digits. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
Generally I block it into pairs of nibbles, pairs of bytes etc. So fff8 could be triple-eff eight but 8ff8 would be eight-eff eff-eight rather than eight double-eff eight. Intuitively it helps highlight alignment errors when the listener hears the pattern break. If a byte is numeric then I speak it like it's in decimal unless my listener shows that they find that a problem then I switch to "seven five" rather than "seventy-five" 0x8000000 "oh ex eight and six zeroes." but I would consider tweaking the code to have an exact power of two nibbles. 0x08000000 "oh ex oh eight and six zeroes" when hand-writing, I use small spaces 0x8000 0000 0x7fff750a "oh ex seven-triple-eff seventy-five oh-a" 0x7ff75f0a "oh ex seven-eff eff-seven five-eff oh-a
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
If you really must, then just say the digits.
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
-
we don't discuss numbers, we discuss functionality, algorithms, and code, not data. So either the hex numbers are user data and off-topic, or they are programming constants and need to be symbolic with a meaningful and pronounceable name. BTW: when I have to write a hex literal, I make sure to provide a number of digits that is a power of 2 (and matches the data type). So 0x80 and 0x8000 and 0x80000000 can be fine; 0x800 and 0x8000000 never is OK. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
we don't discuss numbers, we discuss functionality, algorithms, and code, not data. So either the hex numbers are user data and off-topic, or they are programming constants and need to be symbolic with a meaningful and pronounceable name. BTW: when I have to write a hex literal, I make sure to provide a number of digits that is a power of 2 (and matches the data type). So 0x80 and 0x8000 and 0x80000000 can be fine; 0x800 and 0x8000000 never is OK. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
Right, but in order to give it a meaningful and pronounceable name, you must first communicate the number itself somehow.
that would be in a class, a type, a header file, depending on the language. And it would not be orally, it would always be in a file, a compiler-readable one at best, a document otherwise. The only thing I might consider communicating orally about it (i.e. before the electronic version exists) is the symbolic name. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
that would be in a class, a type, a header file, depending on the language. And it would not be orally, it would always be in a file, a compiler-readable one at best, a document otherwise. The only thing I might consider communicating orally about it (i.e. before the electronic version exists) is the symbolic name. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
I'm afraid that doesn't work for me. I (semi)often find myself in the position of trying to explain an algorithm to someone in real life, in a setting where no non-oral means of communication is easily available.
Hmm. I'd use really small numeric values (think 0x00 thru 0xFF) as examples if I had to, and nothing fancier. And carry issues would be explained at a nibble level, not a byte level, as hex notation is nibblish. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
-
we don't discuss numbers, we discuss functionality, algorithms, and code, not data. So either the hex numbers are user data and off-topic, or they are programming constants and need to be symbolic with a meaningful and pronounceable name. BTW: when I have to write a hex literal, I make sure to provide a number of digits that is a power of 2 (and matches the data type). So 0x80 and 0x8000 and 0x80000000 can be fine; 0x800 and 0x8000000 never is OK. :)
Luc Pattyn [My Articles] Nil Volentibus Arduum
Luc Pattyn wrote:
So either the hex numbers are user data and off-topic, or they are programming constants and need to be symbolic with a meaningful and pronounceable name.
What do you mean, constants and names? Real computers have a hex keyboard and then you can just hack them in, byte by byte. Nothing hard or confusing about having to keep two hex digits in mind at a time. :) Edit: The original version of my old computer still had switches, but entering binary really was a pain. A hex keyboard was a real improvement.
At least artificial intelligence already is superior to natural stupidity
-
I pair them up (since they always represent byte streams e.g. pairs of digits) so that would be 'hex oh-eight oh-oh oh-oh oh-oh'.
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
I rarely ever see the need to pronounce a hex number out loud, and if I do, I either read digit by digit (including the 0x prefix), or lend shortcuts from military style* for repeated occurences of '0', e. g. a sequence of '200' would be "two hundred". I usually only do that with '0' at the end, but there's no reason not to apply it mid-word as well. If your point is to introduce a way of pronouncing hex numbers in a similar way to decimal number shortcuts, maybe you should look at what's there already: e. g. we already have 'double words' (4 bytes) split into a 'high word' and a 'low word', so you might want to pronounce '0x082A3BC8' as "082A high 3BC8 low". * Note that military style reading also pronounces 6 o'clock as "six hundred" (at least that's what I've been taught), so here we already have a precedence where "hundred" equates just a sequence of '0' rather than the value, 100.
-
I pair them up (since they always represent byte streams e.g. pairs of digits) so that would be 'hex oh-eight oh-oh oh-oh oh-oh'.
I, too, pair them but I do not use 'oh' (that is a letter or an octal prefix). Zero is two syllables, so I use nought (tends to end up sounding like nor or norg). This prevents you having ambiguities like in 'Pensylvannia 6-5-Oh-Oh-Oh' which in the UK would be understood as 65000 but in the US could be 65000 or 65OOO (which is 65666). Like other respondents, I'd only expect 2, 4 or 8 digits (prepending with zeros as required). So, I'd end up with hex norg-eight nor-norg nor-norg nor-norg. Writing it down as I say it out loud has shown that I use the 'norg' form before a vowel (like the difference between 'a' and 'an') and before a gap. Listening back to myself, 'nor-norg' sounds a bit like 'knock-knock', which might explain why some wags keep asking "Who's there?". If dictating (e.g. for reading back license keys with full alphabets) with non- / semi- IT literate people, I'd add -er to numbers, e.g. niner sixer aye bee cee fiver fourer. If dicating to more literate users, I'd use numbers without -ers (would they be called 'numb's?) and use the phonetic radio code for letters (not 'lett's), e.g. Charlie-0ne Nine-Bravo Alpha-Six Two-Delta. Note: For MS license keys, I would read out in batches of 5 alphamerics so that the spoken pattern matches the key layout. Most folks can remember 5 alphanumerics long enough to check them; but only in a max of threes for longer term storage (except for telephone numbers where you can use natural breaks)
-
0x80000000: "Zero X Eight followed by seven zero's"0x8A2D35CB: "Zero X Eight A two D three five C B" And yes, I do pronounce the "0x". Since I do user interfaces, half the time I'm talking to users, and the other I'm talking to the yahoos I front for. Adding the "0x" prefix helps keep things unambiguous.Software Zen:
delete this;Same here, except I say "OH-EX" and then the numbers/letters. :D :-D :laugh:
-
How do you do it? For small or commonly used numbers it isn't really a problem, but I haven't really found an "obviously good" way. Just reading out the numbers one by one gets confusing for something like 0x8000000 (which is a zero "too short") and it doesn't convey the approximate magnitude until you've had the last digit. Reading it as "8 million" isn't ideal either (though that way kind of works when there are letters in the number), and actually converting to decimal doesn't work at all - 134217728 probably doesn't ring a bell with many people. Of course pronouncing it as 1<<27 works, but for most numbers there are no "shortcuts" like that.
