What's so special about "32"?

I had to chuckle when I read this question. It’s a perfect example of how
things computer folks take for granted are just so much black magic to “real”
people.

32’s special, because it comes after 16, and before 64. Which of course is
just more black magic, I’m sure.

So we’ll start at the beginning. In the beginning was the bit, and it all
goes downhill from there.

You may already know this, but to refresh, modern digital computers really
only know two things: “1”, or “0”. Or put another way, they can know only
single things, called “bits”, that can be either on, or off. Seriously, that’s
all they know. Every computer program, every digital photo, every music file,
even the text you’re looking at right now is just a collection of bits. A
lot of bits, but only bits … 1’s and 0’s.

Now it’s really cumbersome to have to think of everything as just a series
of 1’s and 0’s, so there are some convenient ways of grouping them. You’ve
probably already heard of a “byte” which is a collection of 8 bits. If you look
at the number of possible different combinations of how those 8 bits can be
set, each on or off, you’ll find that there are 256 possible combinations –
00000000 through 11111111, or more conveniently 0 through 255.

The first popular microprocessors used in personal computers back in the day
of say the Apple ][, were architected to deal with data one byte at a time.
Thus they were called “8-bit” computers.

The IBM PC, when it was introduced used a processor that was effectively a
16 bit processor – handling data 16 bits, or two bytes at a time. Most modern
machines use 32 bit processors, and 64 bit processors are now beginning to
arrive.

In case you couldn’t guess from the progression – 8, then 16, 32 and 64 –
processors tend to double the way that they look at data as the technology
improves. Is a 128 bit processor on the horizon? I don’t know, but I’m sure
there’s one or more in a lab somewhere, if not elsewhere.

As the Intel-based processors used in the IBM and compatible machines grew
in power and made those leaps from 8, to 16 and so on, there was the issue of
software. In general, software written to run on a 16 bit processor would not
run on a 32 bit machine – at least not without help. That help comes in the
form of compatibility modes on the 32 bit processors that allow them to “look
like” 16 bit processors.

In reality, the cart lead the horse. MS-DOS and early versions of Windows
were, in fact, 16 bit software, so the processor was running in this
compatibility mode most of the time. Slowly, as 32 bit versions of software was
written to replace the older code, the processor’s new features, like true
multitasking, proper virtual memory and lots of physical memory, could be
exploited.

But we were still faced with compatibility. 32 bit programs needed 32 bit
support from the operating system, while 16 bit software needed the operating
system to act like it used to. Thus things like “SYSTEM32” were born. It was
the directory to hold the 32 bit versions of Windows components. The old
“SYSTEM” directory was left to hold the older, 16 bit versions.

When you see the “32” in an actual file name, that’s often the result of the
same evolution … that’s probably the 32 bit version of a program that was
once written for 16 bits.

Now what I’ve outlined so far is all the ideal, or the theory, more or less.
It’s best thought of as a rule of thumb, rather than laws that all programmers
had to follow. As we’ve progressed from 16 to 32, and with 64 on the horizon,
these rules haven’t always been followed exactly, and they don’t apply in all
cases. But they do apply in most.