Least significant bit first

While working on ruby I came across:

> "cc".unpack('b8B8')
 => ["11000110", "01100011"] 

Then I tried Googleing to find a good answer on "least significant bit", but could not find any.

Anyone car开发者_开发技巧e to explain, or point me in the right direction where I can understand the difference between "LSB first" and "MSB first".

It has to do with the direction of the bits. Notice that in this example it's unpacking two ascii "c" characters, and yet the bits are mirror images of each other. LSB means the rightmost (least-significant) bit is the first bit. MSB means the leftmost (most-significant) is the first bit.

As a simple example, consider the number 5, which in "normal" (readable) binary looks like this:

00000101

The least significant bit is the rightmost 1, because that is the 2^0 position (or just plan 1). It doesn't impact the value too much. The one next to it is the 2^1 position (or just plain 0 in this case), which is a bit more significant. The bit to its left (2^2 or just plain 4) is more significant still. So we say this is MSB notation because the most significant bit (2^7) comes first. If we change it to LSB, it simply becomes:

10100000

Easy right?

(And yes, for all you hardware gurus out there I'm aware that this changes from one architecture to another depending on endianness, but this is a simple answer for a simple question)

The term "significance" of a bit or byte only makes sense in the context of interpreting a sequence of bits or bytes as an integer. The bigger the impact of the bit or byte on the value of the resulting integer - the higher its significance. The more "significant" it is to the value.

So, for example, when we talk about a sequence of four bytes having the least significant byte first (aka little-endian), what we mean is that when we interpret those four bytes as a 32bit integer, the first byte denotes the lowest eight binary digits of the integer, the second bytes denotes the 17th through 24th binary digits of the integer, the third denotes the 9th through 16th, and the last byte denotes the highest eight bits of the integer.

Likewise, if we say a sequence of 8 bits is in most significant bit first order, what we mean is that if we interpret the 8 bits as an 8-bit integer, the first bit in the sequence denotes the highest binary digit of the integer, the second bit the second highest, and so on, until the last bit denotes the lowest binary digit of the integer.

Another thing to think about is that one can say that the usual decimal notation has a convention that is most significant digit first. For example, a decimal number like:

1250

is read to mean:

1 x 1000 +
2 x 100 +
5 x 10 +
0 x 1

Right? Now imagine a different convention that is least significant digit first. The same number would be written:

0521

and would be read as:

0 x 1 +
5 x 10 +
2 x 100 +
1 x 1000

Another thing you should observe in passing is that in the C family of languages (most modern programming languages), the shift-left operator (<<) and shift-right operator (>>) are pointing in a most significant bit direction. That is shifting a bit left increases its significance and shifting it right decreases it, meaning that left is most significant (and the left side is usually what we mean by first, at least in the west).