KB to MB Conversion Kilobytes to Megabytes Calculator 8,000,000 bits Kilobytes Kilobyte (KB) is a common measurement unit of digital information (including text, sound, graphic, video, and other sorts of information) that equals to 1000 bytes. In practical information technology, KB is actually equal to 210 bytes, which makes it equal to 1024 bytes. Decades ago, this unit used to be one of the most popular ones, but recently, since the volumes of information increased drastically, such unit as gigabyte has become more commonly used. Kilobyte in SI and base 10 (decimal) 1 Kilobyte = 10001 bytes 1 Kilobyte = 1000 bytes Kilobyte in base 2 (binary) 1 Kilobyte = 210 bytes 1 Kilobyte = 10241 bytes 1 Kilobyte = 1024 bytes Megabytes Megabyte (MB) is a unit of transferred or stored digital information, which is extensively used in information and computer technology.

In SI, one megabyte is equal to 1,000,000 bytes. At the same time, practically 1 megabyte is used as 220 B, which means 1,048,576 bytes. Nowadays, the amount of information measured by megabytes is used for representing the size of a typical MP3 file, the size of a JPEG image, and so on.

Megabyte in SI and base 10 (decimal) 1 Megabyte = 10002 bytes 1 Megabyte = 1,000,000 bytes Megabyte in base 2 (binary) 1 Megabyte = 220 bytes 1 Megabyte = 10242 bytes 1 Megabyte = 1,048,576 bytes How to Calculate Kilobytes to Megabytes Kilobyte in SI 1 Kilobyte = 10001 bytes We know that 1MB = 10002 bytes, so 1 byte = 1000-2 MB putting 1 byte in kilobyte equation; 1 Kilobyte = 10001 * 1000-2 MB 1 Kilobyte = 1000-1 MB 1 Kilobyte = 0.001 Megabytes KB to MB in Base 2 (binary) Kilobyte in base 2 1 Kilobyte = 210 bytes 1 Kilobyte = 10241 bytes 1 byte = 1024-2 MB 1

 Kilobyte = 10241 * 1024-2 MB 1 Kilobyte = 1024-1 MB 1 Kilobyte = 2-10 Megabytes 1 Kilobyte = 0.0009765625 Megabytes KB to MB Conversion Table Kilobytes (KB) MB to KB Conversion Megabytes to Kilobytes Calculator 8,000 bits Megabytes Megabyte (MB) is a unit of transferred or stored digital information, which is extensively used in information and computer technology.

In SI, one megabyte is equal to 1,000,000 bytes. At the same time, practically 1 megabyte is used as 220 B, which means 1,048,576 bytes. Nowadays, the amount of information measured by megabytes is used for representing the size of a typical MP3 file, the size of a JPEG image, and so on. Megabyte in SI and base 10 (decimal) 1 Megabyte = 10002 bytes 1 Megabyte = 1,000,000 bytes Megabyte in base 2 (binary) 1 Megabyte = 220 bytes 1 Megabyte = 10242 bytes 1 Megabyte = 1,048,576 bytes Kilobytes Kilobyte (KB) is a common measurement unit of digital information (including text, sound, graphic, video, and other sorts of information) that equals to 1000 bytes. In practical information technology, KB is actually equal to 210 bytes, which makes it equal to 1024 bytes.

Decades ago, this unit used to be one of the most popular ones, but recently, since the volumes of information increased drastically, such unit as gigabyte has become more commonly used.

Kilobyte in SI and base 10 (decimal) 1 Kilobyte = 10001 bytes 1 Kilobyte = 1000 bytes Kilobyte in base 2 (binary) 1 Kilobyte = 210 bytes 1 Kilobyte = 10241 bytes 1 Kilobyte = 1024 bytes How to Calculate Megabytes to Kilobytes Megabyte in SI 1 Megabyte = 10002 bytes We know that 1KB = 1000 bytes, so 1 byte = 1000-1 kilobytes putting 1 byte in megabyte equation; 1 Megabyte = 10002 * 1000-1 KB 1 Megabyte = 10001 Kilobytes 1 Megabyte = 1000 Kilobytes MB to KB in Base 2 Megabyte in base 2 1 Megabyte = 220 bytes 1 Megabyte = 10242 bytes 1 byte = 1024-1 KB 1 Megabyte = 10242 * 1

024-1 KB 1 Megabyte = 10241 Kilobytes 1 Megabyte = 210 Kilobytes 1 Megabyte = 1024 Kilobytes MB to KB Conversion Table Megabytes (MB) What are bits, bytes, and other units of measure for digital information?

Include archived documents ARCHIVED: What are bits, bytes, and other units of measure for digital information? A bit is a binary digit, the smallest increment of data on a computer. A bit can hold only one of two values: 0 or 1, corresponding to the electrical values of off or on, respectively. Because bits are so small, you rarely work with information one bit at a time. Bits are usually assembled into a group of eight to form a byte. A byte contains enough information to store a single ASCII character, like "h". A kilobyte (KB) is 1,024 bytes, not one thousand bytes as might be expected, because computers use binary (base two) math, instead of a decimal (base ten) system. Computer storage and memory is often measured in megabytes (MB) and gigabytes (GB). A medium-sized novel contains about 1 MB of information. 1 MB is 1,024 kilobytes, or 1,048,576 (1024x1024) bytes, not one million bytes.

Similarly, one 1 GB is 1,024 MB, or 1,073,741,824 (1024x1024x1024) bytes. A terabyte (TB) is 1,024 GB; 1 TB is about the same amount of information as all of the books in a large library, or roughly 1,610 CDs worth of data. A petabyte (PB) is 1,024 TB. 1 PB of data, if written on DVDs, would create roughly 223,100 DVDs, i.e., a stack about 878 feet tall, or a stack of CDs a mile high. Indiana University is now building storage systems capable of holding petabytes of data. An exabyte (EB) is 1,024 PB. A zettabyte (ZB) is 1,024 EB. Finally, a yottabyte (YB) is 1,024 ZB. Many hard drive manufacturers use a decimal number system to define amounts of storage space.

As a result, 1 MB is defined as one million bytes, 1 GB is defined as one billion bytes, and so on. Since your computer uses a binary system as mentioned above, you may notice a discrepancy between your hard drive's published capacity and the capacity acknowledged by your computer. For example, a hard drive that is said to contain 10 GB of storage space using a decimal system is actually capable of storing 10,000,000,000 bytes. However, in a binary system, 10 GB is 10,737,418,240 bytes. As a result, instead of acknowledging 10 GB, your computer will acknowledge 9.31 GB. This is not a malfunction but a matter of different definitions.

We count in base 10 by powers of 10: 101 = 10 102 = 10*10 = 100 103 = 10*10*10 = 1,000 106 = 1,000,000 Computers count by base 2: 21 = 2 22 = 2*2 = 4 23 = 2*2*2 = 8 210 = 1,024 220 = 1,048,576 So in computer jargon, the following units are used: Unit 1 petabyte (PB) 1,125,899,906,842,624 bytes Note: The names and abbreviations for numbers of bytes are easily confused with the notations for bits. The abbreviations for numbers of bits use a lower-case "b" instead of an upper-case "B". Since one byte is made up of eight bits, this difference can be significant.

For example, if a broadband Internet connection is advertised with a download speed of 3.0 Mbps, its speed is 3.0 megabits per second, or 0.375 megabytes per second (which would be abbreviated as 0.375 MBps). Bits and bit rates (bits over time, as in bits per second [bps]) are most commonly used to describe connection speeds, so pay particular attention when comparing Internet connection providers and services. This document was developed with support from National Science Foundation ( NSF ) grants 1053575 and 1548562 . Any opinions, findings, conclusions, or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the NSF. This is document ackw in the Knowledge Base. Last modified on 2013-01-07 00:00:00. storage - What is the difference between a kibibyte, a kilobit, and a kilobyte? - Super User What is the difference between a kibibyte, a kilobit, and a kilobyte?

up vote 39 down vote favorite 19 This question got me wondering about the differences between these three ways of measuring size: a kibibyte, a kilobit, and the conventional kilobyte. I understand that these measurements have different uses (data transfer rate is measured in bits/sec), but I'm not quite sure if I can tell the difference between Mb and MB and MiB. Here is a comment, reproduced below, taken from this answer (emphasis mine). The C64 has 65536 bytes of RAM. By convention, memory size is specified in kibiBytes, data transfer rates in kilobits, and mass storage in whatever-the-manufacturers-think-of-now-Bytes. Harddrives use T, G, M and k on the label, Windows reports the size in Ti, Gi, Mi and ki. And those 1.44MB floppys? Those are neither 1.44MB nor 1.44MiB, they are 1.44 kilokibibytes. That's 1440kiB or 1'474'560 bytes.

– Third 11 There will be confusion for years to come. In the early days of computing, people spotted that it was clearly much easier to work with factors of 1024 rather than 1000 for computers. Therefore, for decades, the standard SI prefix "kilo" was (and still very often is) used for the non-standard 1024, and it became a de-facto standard in computing. Except that some people still used the SI 1000 anyway. To sort out the mess, "kibi" is now officially defined as a 1024 factor - but it came far too late for an easy transition. "kilo" will be regularly used/abused for 1024 factors for a while yet. – Steve314 Nov 15 '11 at 6:46 It would have helped adoption if they hadn't chosen prefixes that flat out sound stupid; even an acronym requires someone to "mentally aspirate" the word. I simply will never use "kibibyte", etc.

– tgm1024 Jan 11 at 14:43 1 KiB (Kibibyte) = 1,024 B (Bytes) (2^10 Bytes) 1 kb (Kilobit) = 125 B (Bytes) (10^3 Bits ÷ (8 bits / byte) = 125 B) 1 kB (Kilobyte) = 1,000 B (Bytes) (10^3 Bytes) It's the same way with any SI prefix; k (1x103), M (1x106), G (1x109), so, by extension: 1 MiB (Mebibyte) = 1,048,576 B (Bytes) (2^20 Bytes) 1 Mb (Megabit) = 125,000 B (Bytes) (10^6 Bits ÷ (8 bits / byte) = 125,000 B) 1 MB (Megabyte) = 1,000,000 B (Bytes) (10^6 Bytes

) The only ones that are a bit different are the IEC Binary Prefixes (kibi/mebi/gibi etc.), because they are in base 2, not base 10 (e.g.

all numbers equal 2something instead of 10something). I prefer to just use the SI prefixes because I find it to be a lot easier. Plus, Canada (my country) uses the metric system, so I'm used to, for instance 1kg = 1000g (or 1k anything = 1000 base things). None of these are wrong or right; just make sure you know which one you're using and what it really equates to. To appease the commenters: 1 Byte (B) = 2 nibbles = 8 bits (b) This is why, if you've ever taken a look in a hex editor, everything is split into two hexadecimal characters; each hex character is the size of a nibble, and there are two to a byte. For instance: 198 (decimal) = C6 (hex) = 11000110 (bits) 5 +1 Mentioning that there are 8 bits in a byte may be useful. – paradroid May 23 '11 at 15:52 4 ...and don't forget that a nybble is four bits (or half a byte)!

– Linker3000 May 23 '11 at 15:57 4 Might also be aware that the lowercase "b" is sometimes used incorrectly to abbreviate "bytes". I see a lot of places just use "bit" in the abreviation such at MB for megabyte and Mbit for megabit and stay away from "b" altogether. – James May 23 '11 at 16:02 4 The prefix kilo is abbreviated k, not K. – garyjohn May 23 '11 at 16:19 1 @Redandwhite Nope, they use base 10 to measure their storage, but our computers use base 2. This accounts for the discrepancy between what's printed on the box and what shows up in the computer. For example, 500GB (box) = 465.7GiB (computer) (and that is how they get you).

– squircle May 23 '11 at 16:36 up vote 4 down vote There are a few basic terms that are simple and easy to understand: * A bit (b) is the smallest unit of data comprised of just {0,1} * 1 nibble (-) = 4 bits (cutesy term with limited usage; mostly bitfields) * 1 byte (B) = 8 bits (you could also say 2 nibbles, but that’s rare) To convert between bits and bytes (with any prefix), just multiple or divide by eight; nice and simple. Now, things get a little more complicated because there are two systems of measuring large groups of data: decimal and binary . For years, computer programmers and engineers just used the same terms for both, but the confusion eventually evoked some attempts to standardize a proper set of prefixes. Each system uses a similar set of prefixes that can be applied to either bits or bytes. Each prefixes start the same in both systems, but the binary ones sound like baby-talk after that. The decimal system is base-10 which most people are used to and comfortable using because we have 10 fingers.

The binary system is base-2 which most computers are used to and comfortable using because they have two voltage states. The decimal system is obvious and easy to use for most people (it’s simple enough to multiply in our heads). Each prefix goes up by 1,000 (the reason for that is a whole different matter). The binary system is much harder for most non-computer people to use, and even programmers often can’t multiple arbitrarily large numbers in their heads. Nevertheless, it’s a simple matter of being multiples of two. Each prefix goes up by 1,024. One “K” is 1,024 because that is the closest power of two to the decimal “K” of 1,000 (this may be true at this point, but the difference rapidly increases with each successive prefix). The numbers are the same for bits and bytes that have the same prefix.

* Decimal: * 1 kilobyte (KB) = 1,000 B = 1,000^1 B 1,000 B * 1 megabyte (MB) = 1,000 KB = 1,000^2 B = 1,000,000 B * 1 gigabyte (GB) = 1,000 MB = 1,000^3 B = 1,000,000,000 B * 1 kilobit (Kb) = 1,000 b = 1,000^1 b 1,000 b * 1 megabit (Mb) = 1,000 Kb = 1,000^2 b = 1,000,000 b * 1 gigabit (Gb) = 1,000 Mb = 1,000^3 b = 1,000,000,000 b * …and so on, just like with normal Metric units meters, liters, etc.

* each successive prefix is the previous one multiplied by 1,000 * Binary: * 1 kibibyte (KiB) = 1,024 B = 1,024^1 B 1,024 B * 1 mebibyte (MiB) = 1,024 KB = 1,024^2 B = 1,048,576 B * 1 gibibyte (GiB) = 1,024 MB = 1,024^3 B = 1,073,741,824 B * 1 kibibit (Kib) = 1,024 b = 1,024^1 b = 1,024 b * 1 mebibit (Mib) = 1,024 Kb = 1,024^2 b = 1,048,576 b * 1 gibibit (Gib) = 1,024 Mb = 1,024^3 b = 1,073,741,

824 b * …and so on, using similar prefixes as Metric, but with funny, ebi’s and ibi’s * each successive prefix is the previous one multiplied by 1,024 Notice that the difference between the decimal and binary system starts small (at 1K, they’re only 24 bytes, or 2.4% apart), but grows with each level (at 1G, they are >70MiB, or 6.9% apart).

As a general rule of thumb, hardware devices use decimal units (whether bits or bytes) while software uses binary (usually bytes). This is the reason that some manufacturers, particularly drive mfgs, like to use decimal units, because it makes the drive size sound larger, yet users get frustrated when they find it has less than they expected when they see Windows et. al. report the size in binary. For example, 500GB = 476GiB, so while the drive is made to contain 500GB and labeled as such, My Computer displays the binary 476GiB (but as “476GB”), so users wonder where the other 23GB went. (Drive manufacturers often add a footnote to packages stating that the “formatted size is less” which is misleading because the filesystem overhead is nothing compared to the difference between decimal and binary units.) Networking devices often use bits instead of bytes for historical reasons, and ISPs often like to advertise using bits because it makes the speed of the connections they offer sound bigger: 12Mibps instead of just 1.5MiBps. They often even mix and match bits and bytes and decimal and binary.

For example, you may subscribe to what the ISP calls a “12MBps” line, thinking that you are getting 12MiBps but actually just receive 1.43MiBps (12,000,000/8/1024/1024). Some of the answers are not exact. Let's first make some notes: The prefix "kilo" means 1 000. Prefixing "kilo" to anything means 1 000 of that item. The same is true for "mega" or million, "giga" or billion, "tera" or trillion, and so on. The reason 1 024 exists instead of simply having 1 000 is because of the way in which binary arithmetic works. Binary, as its name suggests, is a base 2 system (it has 2 digits: 0, 1). It can only perform arithmetic with two digits, in contrast to the base 10 system that we use on a daily basis (0, 1, 2... 9), which has ten digits.

In order to get to the number 1 000 (kilo) using binary arithmetic, it is necessary to perform a floating point calculation. This means that a binary digit must be carried each operation until 1 000 is reached. In the base 10 system, 1 000 = 103 (you always raise 10 to a power in base 10), a very easy and quick calculation for a computer to perform with no "remainders", but in the base 2 system, it is not possible to raise 2 (you always raise 2 to a power in base 2) to any positive integer to get 1 000. A floating point operation or lengthy addition must be used, and that takes more time to execute than the integer calculation 210 = 1024.

You may have noticed that 210 = 1 024 is temptingly close to 1 000 and 1 024 to 1 significant figure is 1 000 (a very good approximation), and back when CPU speed was slow as an old dog, and memory was very limited, this was a pretty decent approximation and very easy to work with, not to mention fast to execute. It is for this reason terms with the "kilo", "mega", "giga", etc., prefixes stuck around with non-exact figures (1 024, 2 048, 4 096, and so on). They were never meant to be exact numbers, they were binary approximations of base 10 numbers. They simply arose as jargon words that "tech" people used. To make matters even more complicated, JEDEC have created their own standards for units used in semiconductor memory circuits. Let's compare some of the JEDEC units to SI (standard international) units: Kb = Kilobit (JEDEC, 1 024 bits.

Note the upper case 'K' and lower case 'b') kB = kiloBit (SI, 1 000 bits. Note the lower case 'k' and upper case 'B') b = bit (JEDEC, note the lower case 'b') b = ??? (SI does not define the word 'bit' so its use may be arbitrary) B = byte (JEDEC, 8 bits. Note the upper case 'B') B = ???? (SI does not define the word "byte" and "B" is used for "Bel" [as in DeciBel]) KB = kilobyte (JEDEC, 1 024 bytes. Note the upper case 'K' and 'B') kb = kilobyte (SI, 1 000 bytes. Note the use of the lower case 'k' and lower case 'B') The point is, different places use different prefixes with different definitions. There is no hard and fast rule as to which one you should use, but be consistent with the one you do use. Due to down voting, allow me to clarify why you cannot make 1 000 in binary by raising it to any positive integer.

Binary system: +----------------------------------------------------------------------------------+ | 1 024ths | 512ths | 256ths | 128ths | 64ths | 32nds | 16ths | 8ths | 4s | 2s | 0 | +----------------------------------------------------------------------------------- Notice that in the binary system, the columns double every time. This is in contrast to the base 10 system which increases by 10 each time: +--------------------------------------------------------------------------+ | 1 000 000ths | 100 000ths | 10 000ths | 1 000ths | 100ths | 10s | 1s | 0 | +--------------------------------------------------------------------------+ The first 10 powers in binary (base 2) are: 20 = 1 c# - How to correctly convert filesize in bytes into mega or gigabytes? - Stack Overflow How to correctly convert filesize in bytes into mega or gigabytes? up vote 16 down vote favorite 3 I'm using the DriveInfo class in my C# project to retrieve the available bytes on given drives.

How to I correctly convert this number into Mega- or Gigabytes? Dividing by 1024 will not do the job I guess. The results always differ from those shown in the Windows-Explorer. up vote 42 down vote accepted 1024 is correct for usage in programs. The reason you may be having differences is likely due to differences in what driveinfo reports as "available space" and what windows considers available space. Note that only drive manufacturers use 1,000. Within windows and most programs the correct scaling is 1024. Also, while your compiler should optimize this anyway, this calculation can be done by merely shifting the bits by 10 for each magnitude: KB = B >> 10 MB = KB >> 10 = B >> 20 GB = MB >> 10 = KB >> 20 = B >> 30 Although for readability I expect successive division by 1024 is clearer. Yes, only drive manufacturers use the 1,000-based definitions.

That's why your "4.7 GB" drives are actually 4,700,372,992 bytes, "50 GB" Blu-Ray is only 50,050,629,632 bytes, your "128 kbps" mp3 is actually 128,000 bits per second, a "3.1 megapixel" camera only has 3,145,728 pixels, a 2 GHz processor is actually 2,000,000,000 hertz, a 16 GB/s memory bus is actually 16,000,000 bytes per second, ... – endolith Aug 12 '09 at 20:17 3 1024 is only "correct" in that it represents the actual number of bits on the disk. If you're concerned about correctness however, you need to display that with the unit "GiB". Using 1024 and calling it a "GB" is technically incorrect. GB is officially 1000 million, not 1024 million.

I'd argue that 1000 is the correct usage from a human factors point of view. 1 gigawatts is 1000 megawatts. 1 GHz is 1000 MHz. By the same token (and for easier math by humans) 1000 gigabytes is 1000 megabytes. – Bryan Oakley Aug 31 '09 at 22:37 1 No @Adam, @Bryan is correct. It doesn't make sense that the standard SI prefixes would mean different things when your talking about "drives" or "bytes", it's powers of 10, not powers of 2. e.g. When using powers of 2, the correct term would be mebibytes, not megabytes. – John Leidegren Oct 21 '10 at 6:19 1 @Bryan, @john - Users will complain if your program reports a different number than the OS and EVERY other program. If you want a reasonable user experience you should seriously consider sticking to the common convention.

However, it's your program to do with as you please, and if you're ready to deal with customer questions regarding what a GiB is, or why your software reports different drive sizes than everything else they see, go for it. Keep in mind that the SI prefixes are great for technical documentation, but not necessarily designed for the end user to understand easily. – Adam Davis Oct 21 '10 at 14:56 1 Apple software reports file size and drive storage as 1 GB = 1 billion bytes, and I think I've seen a few other programs do the same. The whole kilo- = 1024 thing arose at a time when saving a few bits on addressable space was a big deal and saving a couple of bit per variable dividing by 1024 was much computationally cheaper than dividing by 1000, but with modern hardware it hardly makes a difference. There's really not much to be gained from caring much about the difference, though. Do whatever makes you happy since some people are going to tell you you're wrong no matter what.

– user2310967 Mar 4 '14 at 13:37 In KBa the extra bit is used for error detection. ;-D – Adam Davis Mar 13 '09 at 18:18 @Adam Davis For ECC RAM that is actually exactly what is done in practice. – starblue Mar 13 '09 at 21:38 15 while funny, it does not answer the question and may confuse those who are easily confused. – Bryan Oakley Aug 31 '09 at 22:41 1 Some machines have non-standard architectures with more or fewer bits per byte than 8. I'm thinking of the UNIVAC 1103/1103A/1105/1100/2200 mainframes with a 9-bits per byte (and the potential to run programs that only use 6-bits per byte). So the KBa would no longer by the Baker's Kilobyte on those machines, but the standard.

– Zarepheth Mar 15 '16 at 17:54 2 Standard or no, it would be ridiculous to report disk usage in a different way than the host OS! – Adam Lassek Feb 19 '09 at 16:48 1 The problem is with those host OS doing it wrong and any end user wondering why the brand new disk he bought in the store reports less once installed than what's printed on its box. – grover Feb 19 '09 at 17:36 1 re: "it would be ridiculous to report disk usage in a different way than the host OS": Snow Leopard (Mac OSX 10.6) uses the value 1000 ( support.apple.com/kb/TS2419 ) – Bryan Oakley Aug 31 '09 at 22:40 1 -1 for the statement of "1024 is actually wrong." IEC might say 1000, but GNU says 1024 (try doing a df -h in Linux). It looks like IEC is just a pawn of hard drive manufacturers.

– User1 Dec 2 '10 at 22:18 Use the standard ignore the others! kB decimal KB binary – Patricio Rossi Feb 11 '16 at 23:06 Snow Leopard changes they way we look at Gigabytes (and megabytes, and kilobytes, as well). | Other World Computing Blog Phil S @ 1:57 pm on May 23, 2011 You know, up until the late 80s, everyone doing anything related to the computer industry followed the computer industry’s established power-of-2 standard, because computers worked in powers of 2 and powers of 10 were not useful. Contrary to some of the comments above, it made perfectly good sense. Memory capacities were dictated by address lines, which meant memory was sized in powers of 2, and it was only reasonable to expect a chuck of data that occupied 4k in memory to also occupy 4k on disk or tape – not 4.096kb. Everyone was fine with this. It was logical, functional, and internally consistent.

Then, around about the late 1980s or early 1990s if I remember rightly, some twit associated with SI (Systeme International, not Sports Illustrated) noticed that the computer industry was measuring things in multiples of 1024 rather than multiples of 1000, and had an absolute conniption fit about it. This Just Would Not Do. It was utterly declassé, quite beyond the pale, completely /nekulturny/. And he got on his high horse and opined that the computer industry should be reasonable and use powers of 10, regardless of whether or not powers of 10 were actually useful in the computer industry context. And there it would probably have ended, had not his little snit come to the attention of the storage industry (not that I’d, like, you know, mention Seagate by name or anything …. wait, was that my out-loud voice?), which did the math and realized that this would mean they could take the exact same disk they were selling today, relabel it, and sell it as a bigger hard disk tomorrow. They promptly swarmed all over this idea like a pack of tiger sharks mobbing a wounded whale.

It was like a license to print money. Today’s 100MB disk was tomorrow’s 105MB disk, and all they had to do was change the label. A 400MB disk was now a 420MB disk, with a corresponding price increase, for exactly the same hardware. And we’ve been stuck with it ever since. With the enthusiastic backing of the computer storage industry, and over the objections of the rest of the industry, we got saddled with the silliness of the Gibi-rish units, and hard disks whose capacity was measured in different units than the memory that went into the same computer. And it all started because of one person who was offended that the practical usage that made perfect working sense in binary computer architectures was untidily inconsistent with the Great SI Scheme of Things. “A foolish consistency is the hobgoblin of little minds.” — Ralph Waldo Emerson cb alyn @ 11:33 am on March 12, 2010 You are all forgetting about the lawsuit brought against Seagate over the measurement of hard rive space. The rest of the industry will be following suit. The lawsuit is Cho v.

Seagate Technology (US) Holdings, Inc., San Francisco Superior Court, Case No. 453195. In the suit, the plaintiff alleges that in the sale and marketing of hard disc drives, Seagate has denied and continues to deny each and all of plaintiff’s claims, and denies that anyone has been harmed or deserves compensation. The Court has not made a decision on the merits. Plaintiffs and their counsel have previously been awarded attorneys’ fees, expenses and incentive awards in the amount of $1,792,000, to be paid separately and in addition to the benefits available to settlement class members. Awarded amounts will be paid only if the settlement is approved. All claims of settlement class members which were or could have been asserted in the litigation, based upon the facts alleged in the litigation (as well as in a related case entitled Lazar v. Seagate Technology LLC, et al., San Francisco Superior Court, Case No. 439700; and California Court of Appeal, Case No. A116350) will be released. ALimas @ 1:30 am on February 27, 2010 What’s really important is consistency.

With this SL change, there’re more confusions caused due to the way Apple introduced the change. I can just see how some script somewhere breaks because of this dumb move. Is Apple going to change the definition of something like “du -h”, as well? Or are they even going to just update the man page for that? And, think about it. This is just a small and simple example. I love using my Macs, but this move by Apple is not something I’d applaud them for. I’ve been using Apple computers since the Apple ][. Apple was OK with the definition of what a “kilobyte” is up to SL and now they think they should just suddenly make this change and hope to make it be less confusing for consumers with this change adopted in SL? Yes, there are some smart people at Apple but what they did with SL (whether Engineering or Marketing or Steve Jobs driven) was not a smart move. I agree that by using different “unit symbols” is a way to clearly differentiate to avoid confusions and, like what other posters mentioned, Apple should at least have made it be an option as it’s definitely confusing to look at the file sizes for a shared drive from different platforms. It’s not about old habits.

It’s about how to properly approach introducing a change like this. As a side note, quoting from : “In The Art of Computer Programming, Donald Knuth proposed that this unit be called a large kilobyte (abbreviated KKB).” It’d be amusing if a “large gigabyte” is not referred to as GGB but as KGB. ;^) Knowing this, now, how many bytes is a kilobyte? the only right awnser would be 1000, and awnsering 1024 is just plain dumb. Bill @ 9:29 am on September 12, 2009 I suppose you idiots think that optical disks like DVD and Blu-Ray are marketed in decimal to inflate their capacity, too, right? Even though the size is defined in the specs and disks made by different manufacturers are all the same size? And I suppose processors and network cards and memory buses are all measured in decimal megahertz to inflate their speed? Please, use your brain for once. Apple is doing it right. Using “k-” to mean 1024 was wrong in the 1960s, and it’s even more wrong now.

Zeph @ 10:33 am on September 10, 2009 I’ve been a programmer since mainframes had memory listed in “Kwords” (“words” varied in the number of bits). I continue to write software where binary sizes matter (eg: with 14 bits you can have up to 16,384 values, and it’s easier to say 16K) so I intimately understand the usefulness of binary prefixes in programming. Nevertheless, the decimal prefixes (M = 1,000,000) are way more logical for everything but some programming tools. Apple has switched to decimal prefixes, Linux is in the process thereof, and hopefully Windows will switch soon. Actually, in Windows XP for example, if you right click and choose properties for a selected drive or group of files, Windows will already report exact bytes in decimal as well as an approximation in binary units. If they will switch to using decimal approximations (3.1 GB = 3,100,000,000 B) then this little aspect of the world will become a bit saner.

In the relatively rare cases where one needs binary prefixes, use the new unambiguous ones: KiB, MiB, GiB etc. Use KB, MB, GB etc only for power of ten. This is not a marketing ploy, it is common sense once you get over old habits. Suppose disk drive manufacturers used binary prefixes. Then 1.5 Terabytes would be 1536 Gigabytes, or 1500 Gigabytes would be about 1.465 Terabytes. Every time you cross a 1000 boundary in adding or multiplying, you would need to adjust your figures. Quick: 400 files averaging 22 MBytes each would take up how many gigabytes? Decimal usage answer: 8800 MB or 8.800 GB. Binary usage answer: 8800 MB or 8.594 GB Or round to 8.6 GB. Even as a programmer, the former makes a lot more sense for normal usage.

Currently, a 700 MB CD holds 700 x 1024 x 1024, while a 4.7 GB DVD holds 4.7 * 1000 * 1000 * 1000 and a 1.44 MB floppy held 1.44 * 1000 * 1024. USB 2.0 rates are 480 x 1000 x 1000 bits/sec, a 500 GB drive holds around 500 x 1000 x 1000 x 1000 bytes. The only way this is going to get consistent is to adopt decimal throughout. It’s time we cleaned up our acts. While I mostly work with Windows and Linux, I applaud Apple for leading the way and having the courage to stand up to the conservatives who have trouble switching. It will not be long before Apple folks are somewhat justifiably ridiculing Windows for it’s backwardness in this regard (rather than complaining to Apple). Hopefully Microsoft will see the light. Jay G.

@ 4:34 pm on September 4, 2009 John F, Actually, displaying storage as multiples of 1024 was an early fudging of the numbers to make it easier for us humans to read the numbers. A computer doesn’t think “this file is 1024 bytes,” it thinks, “this file is 10000000000 bytes”. 1024 was “close enough” to 1000 for early programers to consider at a “kilo” (aka 1000) byte, to make larger number of bytes easier to read. But as storage sizes have increased, this arbitrary way of counting has gotten outmoded and confusing, since it’s consistently borrowed base-10 abbreviations, kilo, mega, giga, and used them in a base-2 environment. Raptor007 @ 7:55 pm on August 31, 2009 John F speaks the truth. Apple shouldn’t be helping the drive manufacturers cover up their dishonest representations of space in this way.

Instead, the drive manufacturers should be legally required to advertise the base-2 representations, which have been accepted standards in computing since its inception. I hope we can disable this misrepresentation in 10.6.1. I couldn’t find a way in 10.6. John F @ 5:24 pm on August 29, 2009 The drive manufacturers seem to have snowed everyone, including both Apple and the writer of this blog DECIMAL kilobytes, megabytes, gigabytes, and terabytes were wrong in the 1980s (when the drive manufacturers started lying about drive capacity), and they’re even more wrong now. Computers simply do not allocate and use memory (including block-structured storage such as disk space, flash memory cards, or USB sticks)) in *ANY* unit that is a multiple of 10. Therefore, to be accurate, the storage on any block-structured storage medium MUST be marketed using multiples of 1024 bytes — otherwise it’s a lie, plain and simple. Until the drive manufacturers stop using “marketing” gigabytes, they will be as wrong as TV manufacturers who used to lie routinely about the diagonal measures of their picture tubes.

They’re stating that the device has more capacity than it really does. Period. Timo V. @ 1:28 pm on August 29, 2009 Ah, finally someone gets it. G (giga) is exactly 10 to the power of 9, not something 7.3 % larger (that programmers think so doesn’t overrule IEC or SI). Like the base-2 prefixes? Use kibi, mebi and pals, don’t overload the well-defined SI base-10 prefixes. Besides, computer doesn’t think in base-2 gigabytes, it thinks in bytes. Kilos, megas, gigas, teras and so on are only to make the representation more pleasing and easier for our human brains to visualise. Sometimes, correcting a fault is worth the hassle. Now only if certain other major vendors followed suit… Auughh @ 11:16 am on August 29, 2009 It’s funny how people who are supposed to be experts don’t understand how computers store decimal numbers in memory. A kilobyte is 1000 bytes, not 1024.

That’s 1111101000 in binary, and no, computers have no trouble storing this in memory or representing it as “1000 bytes”. Dividing by 1024 makes absolutely no ******* sense when reporting numbers like this to the user. It adds an extra layer of complication and calculation with no benefit. I suppose when Google Earth says “256 km”, you think it means 262,144 meters? Because computers work in base 2, right? Idiots. T Mitchell @ 9:58 am on March 13, 2012 “It’s funny how people who are supposed to be experts don’t understand how computers store decimal numbers in memory. A kilobyte is 1000 bytes, not 1024. That’s 1111101000 in binary, and no, computers have no trouble storing this in memory or representing it as “1000 bytes”. Dividing by 1024 makes absolutely no ******* sense when reporting numbers like this to the user. It adds an extra layer of complication and calculation with no benefit.

I suppose when Google Earth says “256 km”, you think it means 262,144 meters? Because computers work in base 2, right? Idiots.” I’m afraid your argument is flawed because firstly computers used the base 2 (Binary) numbering system for capacities and sizes and always have done, windows and unix have even now still use the base 2 system when displaying file or disc sizes when using the command line or certain system tools. secondly your comparison of memory sizes to distances are two totally different units of measurement and not even remotely related. and for your information 256 km is 256,000 meters or 256,000 m 1 KB = 1024 Bytes? No, 1 KB = 1000 Bytes! – Christian Neumair 1 MB = 1000 * 1000 Bytes 1 GB = 1000 * 1000 * 1000 Bytes?

I filed a bug report against glib, with an historical analysis of the usage of all conventions and formalized nomenclatures in existence (slightly wrong) demanding that g_format_size_for_display() uses the latter conventions. This actually matches IEC recommendations. One important side-effect of the conventions are: K=1000: Memory sticks and main memory cells are made in powers-of-two – because the address line uses binary logic (i.e. powers-of-two). Historically, their size is advertized with K=1024 to get nice, non-fractional values. Below the 1 GB limit, they were probably advertized with kB rather than KB – but that shouldn’t be relevant anymore. With K=1000, on your computer screen memory (and memory sticks) shows up LARGER than advertized. K=1024: Hard disks do not have such cell architectures, and they are advertized with K=1000. It was some kind of marketing trick in the very beginning, making the disk look larger than you expect, when you set K=1024 as old-fashioned “IT geek”.

The effect is that with K=1024, on your computer screen hard disks look SMALLER than advertized. Compare for yourself: Which of the two statements is positive, psychologically: In contrast to Windows, under Linux my 70 GB hard disk has 70 GB as advertized, and my 1 GB memory sticks grow to 1,07 GB Like under Windows, under Linux my 70 GB hard disk shrinks to 65,1 GB and my 1 GB memory sticks have 1 GB as advertized Wouldn’t it also be nice to have a 100 MB file with 100 * 1000 Kilobytes? No more calculator I/O or right-clicking required for estimating the “actual” size in byte units! I am mostly writing this blog entry to get some feedback from our users, rather than from programmers. Please also mention your background in your blog comments! Further concrete information regarding historic conventions and IEC and SI standards is available in the bug report mentioned above.

Also note that I do NOT demand to use the additional odd KiBi, MiBi, GiBi IEC convention that in fact make the current situation worse by using prefixes nobody knows, still defining Ki = 1024. My guess is that it was just introduced for offering an alternative for traditionalists who probably wanted “some convention with the beloved 1024”. But it is a non-traditional measurement prefix for a traditional concept, which makes it unattractive both for old(-fashioned) traditionalists and young pragmatists. Update I removed the possibly intimidating roundhouse kicks against IT community, and somewhat out-of-context IRC log excerpts. Sorry if anybody felt insulted – some certainly did. You can find an interesting collection of opinions and personal backgrounds in the blog comments. Posted on

Question: Despite its name how many bytes are actually in a kilobyte?
Answer: 1024