While the main contents of the article aren't too wrong, I just have to point out that 32 bits of addressing gives you a 4Gb addressing space. (Unless of course you use signed pointers, in which case you'd have to point out where you keep the negative memory.)

Also, most current 32-bit processors can already support more than 32-bits addressing. (For example G4 PowerPCs and pentiums since P3 support at least 36-bits physical addressing.) Of course, using 32-bits in usercode it's impossible for a single task to access more than 4Gb.

The article also failed to mention the end of the epoch in 2038, when 32-bit signed unix-style time will rollover.

While it may be true that 64-bit code on x86 is bigger than 32-bit (or 16-bit) code, this is mainly caused by having to shoehorn extra instructions into an existing instruction set.

There is no a priori reason that code that operate on 64-bit values needs to be larger than code that operates on 32-bit values. On the contrary, you might be able to do with fewer operations (if you really need to operate on values with more than 32 bits).

So you should be careful about making this assumption (or at least make it clear that it applies only to x86).

I think you will discover [and you may wish to enquire of AMD Dresden about this] that IT has moved into Viable Imagination rather than Memory as the Next Generation Processing Architecture. And a very Bolshie dDevelopment IT is too.

A few random bits "written in PerlyGatesPython Transparent Source Code." would most definitely identify to them the Innovative Programming, should they be at a loss to either confirm or deny any Inquiry...... but you would hardly blame them for that in such a competitive Intel field.

You're forgetting one huge advantage x86-64 has over normal x86 - normal x86 is badly register-starved. x86-64 has a lot more registers, which means at lot less having to go looking in memory for data. Even if data is in L1 cache it's still quicker to have it in a register...

The Alpha is sadly defunct, and indeed applications didn't often need the 64 bit addressing that it gave.

However today's applications still owe a huge amount to the Alpha. Back in the mid 90s there were many applications that simply wouldn't work out of the box on an Alpha system.

Too many coders assumed that an "int" and a "void *" were the same size. On 32 bit systems that was generally true, but on the Alpha it wasn't. I myself submitted patches to many OSS projects to fix 64 bit compatibility, and coders gradually got better at not making those assumptions.

Without the Alpha we'd still be facing issues getting today's applications to compile on modern 64 bit systems.