Hacker News Reader

Comment by danaliv | Hacker News Reader

It’s a shame we didn’t go with “long megabyte,” etc. instead of the god-awful binary unit prefixes.

The native base of our computing systems is base-2. Engineering prefixes for this base should thus also be based on natively divisible break points.

It just so happens that some break points are usefully close (but not quite the same as) base 10 break points.

2^10 = 1024 ~~ (1 KB) ~~ 1000

Naturally given this 2.4% bonus to base 10, and failing upwards in being able to cleanly store the corresponding base 10 datatype, the natural thing to do is to favor the larger and also native unit.

For me, KB will _always_ be 1024 bytes. In the context of computers this is what makes sense.

Similarly I only ever want those to be the binary (base 2, also implied by bytes) base sizes for all other units of storage, data transfer speed, etc. The marketing fixation on providing less value by focusing on the non-native to the system human sizes that are smaller is the error.

Counter-argument to anyone arguing otherwise. What is the size of the smallest addressable unit in any of the block based device storage you care about? Hard disks / flash? (512, 4096, or possibly some very large power of 2 for SMR). CDs/DVDs? (2048 bytes)

Sure, but megabytes and terabytes are just arbitrary numbers. There’s nothing where they correspond to a meaningful device limitation. KB should be 2^10 bytes and MB should be 1e6 bytes. There’s no reason to link them.

2^28 bytes / 256 MB / CSMB (#1) is the size of current SMR spinning rust drives. The flash zone size used in more modern consoles (E.G. PS5 / Xbox whatever) might similarly be 128 MB / CSMB.

#1 (256 Computer Science Mega Bytes) is the size of the minimum write zone for 'zoned storage' according to the Wikipedia page. https://en.wikipedia.org/wiki/Shingled_magnetic_recording#Pr...

Edit + Update: I recalled incorrectly, 128 CSMB "Sony's patent proposes going way beyond 32kB chunks to using 128MB chunks for the FTL" https://www.anandtech.com/show/15848/storage-matters-xbox-ps...

> 2^10 = 1024 ~~ (1 KB) ~~ 1000

2^10B = 1024B = 1KB ~ 1kB = 1000B

as I understand it. And for MB or Mb the accuracy is not really interesting.

Edit: It should in fact be 1kB ~ 1000B

E.g. 1kg is not exactly 1000g, that would be 1.000kg.

But 1KB is meant to be exactly 1024B.

> 1kg is not exactly 1000g, that would be 1.000kg

Really? Why? I would have assumed that 1kg is in fact exactly 1000g, and that the trailing zeros in 1.000kg indicated a rounding to three decimal places: i.e. 999.5g <= 1.000kg < 1000.5g

I may have used ‘exactly’ sloppy here. What I mean is: When the context doesn’t say otherwise, one should assume accuracy or precision as rounding to the least significant digit given. I.e. by default 1kg may indicate a mass between 500g and 1.499g. If the accuracy is about 10g you should write 1.00kg.

Base 10 Engineering Notation uses SI Prefixes, for these a set of letters exist with the upper-case indicating positive exponents (large numbers) and lower-case indicating negative exponents (small parts of one unit) https://en.wikipedia.org/wiki/International_System_of_Units#...

Offhand, and at a glance, none of the upper case correspond to a lower-case prefix. This is probably to detect incorrect usage.

In Computer Science / programming generally, the convention has been that an uppercase B indicates bytes, while a lowercase indicates bits.

Modern computing systems frequently address integer numbers of size 64b, 32b, 16b, 8b (8B, 4B, 2B, 1B respectively).

Examples:

1 Gb (SI G bit, since if discussing bits telecom stuff is implied; I argue that this too is incorrect, but it's efemeral, not storage. Still I can't send less than a byte.)

1 GB (CS G Byte) storage somewhere, memory. Invariably a base 2 power since otherwise packing and transcription to accommodate re-packing would be a power-hungry nightmare.

> upper-case indicating positive exponents (large numbers) and lower-case indicating negative exponents

The prefix kilo is lower case k. Hecto and deca are also lower case abbreviations.

It’s highly context dependent if 1GB means exactly 2^30 bytes or another number in the neighborhood of 1GB.

> Counter-argument to anyone arguing otherwise.

The argument is pretty straightforward. Kilo, Mega, Giga, etc. are already well defined prefixes and it is simply confusing if we start to redefine them in some context.

I agree that clearly hardware manifacturer are taking advantage of this confusion to inflate their marketed memory size, but again they are using the proper meaning of the prefixes. Maybe the solution would be to require them using KiB, MiB or GiB, but certainly not to change the meaning of Kilo.

It's 2.4% for 1KB, but it's 10% for 1TB.

Also, things started to go downhill pretty early on: 1.44MB floppy disks were 1440KB where 1KB was 1024.

Mibi you just don't like them because they are new? You should gibi them a chance.

I reabd thbis wholbe combment wib mby toumbge imb mby teebth

Ebdit: whoebver downbvotes tgbis canb hear mbe sbpeakinbg it

Thou shalt not speak ebcdic!

In my opinion the most important factor by far is avoiding ambiguity. This means sucking up to the binary prefixes and using them in every scenario possible.

A lot of people don't like how they sound, and would like for the standard prefixes to have one meaning, but the reality of the state of the world is such that you will create ambiguity if you don't use the binary prefixes.

In my experience, they're just as likely to be read as a weird typo of mega/giga as not and I've seen SSDs advertised using the wrong prefixes a lot, so there's another layer of ambiguity we wouldn't have if those prefixes had been picked with relative laypeople in mind. Even people who should know about these use 1024 for a kilobyte, and I usually add (1024^3) or something like that if ambiguity is a potential issue. I've been burnt before by trusting that gibi will be understood.

My particular set of anecdata would strongly suggest it's not a very successful standard so far. That "nearest power of two to decimal kilo/mega/giga" is a weird concept in itself doesn't help, and the chosen prefixes are completely non-obvious and alien to me and apparently others as well. I don't think it's going to take hold anytime soon.

Besides, if ambiguity is all there is to worry about, just use 2^30 bytes. No ambiguity at all (I believe) – but it may be a lot less effective in actual communication in lots of situations.

Preferably "megabyte" and "short megabyte", because that will annoy HDD manufacturers more.

Maybe the prefix and separation: SI M B

(SI for https://en.wikipedia.org/wiki/International_System_of_Units The International System of Units (SI, abbreviated from the French Système international (d'unités)))

((International System of Units) Mega) Bytes

-- Edit, addition

Additionally, I'd be willing to prefix my preferred units some variation of:

Base Two M B (BTMB)

Computer Science M B (CSMB)

Does anyone actually have a problem with kB meaning 1024 bytes and MB meaning 1<<20 bytes, etc?

Sure, the kilo-, mega- etc prefixes might literally mean 10^x but as long as one is raised with the understanding that to do so is overly literal, then it’s never really a problem. base = 2 if context == computer else 10

Kibi and mibi feel like this generation’s centripetal force. Another popular and unsolicited explanation I get a lot is about equality vs equity. The distinction might be real but after being corrected for the nth time one feels like I am being corrected for the sake of it than for any real reason.

People don't use it like you say. My SSD that says "500 GB" on the label is actually only 500e9 bytes or 465 gibibytes. If I see a file size listed somewhere, I never know which version of the unit it's using so I tend to think in terms of bytes anywhere that the difference matters.

The shrinkage is all just Sales and Marketing ignoring engineering sensibilities in the quest for a bigger number on the box.

The underlying storage cell arrangement is still (typically) 4096 bytes in size. (or 65536 (64KB) for many embedded devices).

The device probably has about 10% of it's real storage capacity dedicated to ECC and other 'administrative' uses for provisioning the user facing storage.

It doesn't matter the reason. At the end of the day, it's used inconsistently so you can't just treat GB as meaning GiB when it's to do with computers and the units have become a confused muddle.

Context is everything and I’m fine with that.

I can handle the base2 / base10 problem by using context. I don’t need a clumsy new prefix.

If someone on the street asked you how much memory your computer has, how would you answer? “Seven gigs”? “Seven gibs”? “Seven gibibytes”?

> I can handle the base2 / base10 problem by using context. I don’t need a clumsy new prefix.

I feel numbers ure a much more powerfull abstraction than any particular unit, so when there is friction like this between conventions, I prefer to favor the number. Giga is 10⁹ and Gibi is 2¹⁰⁰ whatever the actual unit behind it.

Perhaps you have a clearer picture of when GB is a power of ten and when it's a power of 2. Now I think of it, maybe it's only hard drives that use powers of ten? Hmm, what about SD cards? Internet bandwidth? Anything that might be labeled for marketing purposes? To me it's still a blur.

> Does anyone actually have a problem with kB meaning 1024 bytes and MB meaning 1<<20 bytes, etc?

The manufacturers of memory and hard drives seem to have always had a problem with that. They’ve preferred to use KB=1000 bytes exactly, MB=10^6 bytes, GB=10^9 bytes, etc. for as long as I’ve been buying computers, which is long enough to remember when computers didn’t come with MBs.

What’s bad about the binary prefixes? Does it help if you think about how it’s designed to be “MEga BInary” and “GIga BInary”? Or is that the problem?

The talk of weird sounding binary prefixes and long scales reminds me of the British long scale for large numbers that has different names for what we know as ‘million’ and ‘billion’: “milliard” and “billiard” (not to be confused with pool.) https://en.wikipedia.org/wiki/Long_and_short_scales

Knuth once suggested "large megabyte" (and so on) with a wicked abbreviation "MMB" (for "both binary-ness and large-ness").

He has also suggested https://en.wikipedia.org/wiki/-yllion

Reply on news.ycombinator.com