Little-endianness has got its elegance and is even more coherent: the lowest address takes the byte with the lowest weight: neat! Big-endianness, on the other hand, has it backwards: lower weight goes to higher address. So, as far as the inner workings of the machine go, I have no real reason to prefer big-endianness: I acknowledge the greater abstract elegance of little-endianness, but I don't actually care that much, as long as thing are working.
As soon as I peek inside the machine, however, I see things differently. I tried to explain this in posts #3 and #35. When I do hex dumps of the EEPROM, then it's little-endian that seems backward and big-endian feels more natural, because I dump from address 0x000 up to address 0x3ff and in this case I see the heaviest byte first (to the left of the monitor), which is coherent with how I read decimal numbers every day.
P.S. The function I use for dumping emulates the output of GNU's od - t x1, with some minor differences. If I save a string to EEPROM with
EEPROM.put(0, "foobar");
the first line of dump output reads like
0000 66 6F 6F 62 61 72 00 FF FF FF FF FF FF FF FF FF
with the lowest address taking the lowest index of the array: this way I can convert the bytes to ASCII in my head (with a cheat sheet in front of me, of course!) and read the string from left to right, like I do in normal English.
But when I do
EEPROM.put(0x40, 0x12345678);
my dump looks like
0040 78 56 34 12 FF FF FF FF FF FF FF FF FF FF FF FF
If a machine could understand, it wouldn't understand what the fuss is all about: "I did exactly what you liked the last time, Master: lowest weight to lowest address, exactly like you ordered me to." Yes, but I'm not happy with the result when I look at it. I'm not a machine, and to me, that thing is weird and a potential source of bugs. Problem is: to a machine, the 'f' in "foobar" and the 0x78 in 0x12345678 are the same thing, i.e. the lowest byte in a sequence of bytes. What the bytes represent to me is not the machine's business. But we humans (OK, humans with a Latin alphabet, and I'm one of them) read words and numbers differently: it feels natural to expect the heaviest digits on the left. On the other hand, we have no concept of "heavy digits" when reading words.
So, to me, when the following two conditions are met:
- We just want to save multi-byte integers to EEPROM, and
- We rely on memory dumps in the form I have shown for debugging
then, big-endianness is better suited for the task because it looks more natural and it is coherent with how we read and write numbers on paper.
Nonetheless, I must admit that this feeling of mine is not as universal as I thought: this discussion has shown it.