Should I try to do practice problems in assembly?

Question

I was looking at Project Euler Problem 48:

The series, 1¹ + 2² + 3³ + ... + 10¹⁰ = 10405071317.

Find the last ten digits of the series, 1¹ + 2² + 3³ + ... + 1000¹⁰⁰⁰.

In Python I can do this with a single line :

sum((x**x for x in xrange(1,1001))

But the assembly equivalent of this would be 100 lines and a real challenge.

Should I be doing some of these puzzles in assembly to gain some insight into low-level programming and understand how the computer actually works?

Answer 1

Beyond learning assembly, I believe that learning how a low-level language like C is compiled is highly valuable. So my answer is yes, but then again I'm probably biased because I enjoy low-level programming.

For example, just understanding how simple statements are compiled. The following function,

int func(int val)
{
  int num = val * 5;
  return num;
}

...becomes (the interesting bit at least):

movl    %edi, -20(%rbp)
movl    -20(%rbp), %edx
movl    %edx, %eax
sall    $2, %eax
addl    %edx, %eax

This code takes the argument from the stack (val, the parameter to func), shifts it the left 2 places (multiply by 2^2 or 4) and then adds the original value to the result. The end result is a multiplication by 5. An example like this illustrates a number of things to be aware of, such as compiler optimizations. Instead of calling an instruction to directly multiply by 5, it shifts two places to multiply by 4 and then adds the original value. I found examples like this to greatly improve my understanding of things at a lower level.

Generate assembler output from gcc with the -S option. However, be aware that the results will vary by compiler and optimization level.

Anyway, I don't think being an assembly language programmer is the same as understanding assembly. Again, I feel that programming in a language like C and knowing how it gets put into machine code is a valuable practice.

Answer 2

Probably not necessary to actually be able to write assembler (most of which sis details of the initialisiation and calling convention for your system).

It is worth understanding some, in case you are trying to debug something without source.

BUT it is definitely worth understanding the machine at least at the level of 'C' and pointers (essentially a high level assembler) so that you know why concating a string a million times in a loop is bad.

Answer 3

Good question. Learning Assembly is definitely good and worth the effort.

1. Such low level understanding will be of good use in embedded software development
2. Refactoring at a low level
3. It will help you in effectively utilizing the debugger
4. Give you an understanding of disassembled code to help in stuff like code caves

Answer 4

Yes and no.

While it is true that it will grant you a better understanding of what your code is doing and why some things are just a bad idea you have to think about the effort.

Learning assembler is not a weekend project, it will take you a lot of time and you need to think whether or not this time could be better spent.

If your not into optimised code then you probably wont ever see benefits equal to the effort you put in.

Answer 5

I did a lot of assembler when I was younger and I don't think it helped understand anything outside of assembler. If you take a look at modern assembler it's all macro language stuff anyway. I usually hate analogies, but here goes anyway: Does knowing how the engine of a car works make you a better driver?

Answer 6

The way I've been working on understanding assembler is by writing programs in higher-level languages, then replacing parts with (at least hopefully) functionally equivalent tracts of assembled code. This means I get to use HLLs for what they're good for-organising and solving high-level problems-and I use asm for banging the metal.

(When I talk about the host program being written in a HLL, I mean C or ObjC when I'm trying to learn x86_64 asm, and BASIC when I'm working on Z80, 6502 and 6809 asm).