Question

I am a firm believer in the idea that one of the most important things you get from learning a new language is not how to use a new language, but the knowledge of concepts that you get from it. I am not asking how important or useful you think Assembly is, nor do I care if I never use it in any of my real projects.

What I want to know is what concepts of Assembly do you think are most important for any general programmer to know? It doesn’t have to be directly related to Assembly – it can also be something that you feel the typical programmer who spends all their time in higher-level languages would not understand or takes for granted, such as the CPU cache.

Answer 1

I think assembly language can teach you lots of little things, as well as a few big concepts.

I’ll list a few things I can think of here, but there is no substitute for going and learning and using both x86 and a RISC instruction set.

You probably think that integer operations are fastest. If you want to find an integer square root of an integer (i.e. floor(sqrt(i))) it’s best to use an integer-only approximation routine, right?

Nah. The math coprocessor (on x86 that is) has a fsqrt instruction. Converting to float, taking the square root, and converting to int again is faster than an all-integers algorithm.

Then there are things like accessing memory that you can follow, but not properly apprecatiate, until you’ve delved into assembly. Say you had a linked list, and the first element in the list contains a variable that you will need to access frequently. The list is reordered rarely. Well, each time you need to access that variable, you need to load the pointer to the first element in the list, then using that, load the variable (assuming you can’t keep the address of the variable in a register between uses). If you instead stored the variable outside of the list, you only need a single load operation.

Of course saving a couple of cycles here and there is usually not important these days. But if you plan on writing code that needs to be fast, this kind of knowledge can be applied both with inline assembly and generally in other languages.

How about calling conventions? (Some assemblers take care of this for you – Real Programmers don’t use those.) Does the caller or callee clean up the stack? Do you even use the stack? You can pass values in registers – but due to the funny x86 instruction set, it’s better to pass certain things in certain registers. And which registers will be preserved? One thing C compilers can’t really optimise by themselves is calls.

There are little tricks like PUSHing a return address and then JMPing into a procedure; when the procedure returns it will go to the PUSHed address. This departure from the usual way of thinking about function calls is another one of those ‘states of enlightenment’. If you were ever to design a programming language with innovative features, you ought to know about funny things that the hardware is capable of.

A knowledge of assembly language teaches you architecture-specific things about computer security. How you might exploit buffer overflows, or break into kernel mode, and how to prevent such attacks.

Then there’s the ubercoolness of self-modifying code, and as a related issue, mechanisms for things such as relocations and applying patches to code (this needs investigation of machine code as well).

But all these things need the right sort of mind. If you’re the sort of person who can put

while(x--) {   ... } 

to good use once you learn what it does, but would find it difficult to work out what it does by yourself, then assembly language is probably a waste of your time.