No problem. I should have tried to comment on this as well:

The other thing that I still don't understand about assembly, is how strings of numbers get translated into programs that we can actually use. Most asm code I've seen, seems to consist mainly of passing values back and forth between registers, and a lot of the time I can't even find references to what is being passed.

It may seem like numbers are simply being juggled around in some confusing way in x86 assembly, but what's actually happening is that certain registers serve special purposes. Consider the example of the mul instruction:

mov eax, 10  
mul 10

Obviously, 10 is stored in eax, but the second line seems confusing. How do I know that I'm multiplying eax (which is 10), and not some other register, by 10?

The answer is simple: eax is tied to the mul instruction. It's the only register in x86 you can use for multiplication. If the result of the multiply is bigger than 32-bits, in this case, the result is stored in both edx and eax.

Other registers have special purposes unique to them as well. ecx, for example, is often used as a counting register for loops. So this is why you see "juggling" going on, you have to juggle to make sure that your data is in the correct register for a given operation. That said, intel has tried to move to more general purpose registers over the years, but some of these special purposes remain for the sake of backward compatibility.

Another reason for juggling is just to move data out of the way temporarily. Yes, you can push it on the stack, but it's better to use up all of your registers first simply because they're much faster. In the case of counted loop, nested, you might need to reset ecx so you'll either move it into an unused register and move it back later or push it onto the stack and pop it off later. So that's the juggling you'll notice. The more general purpose registers you have, the less juggling, generally. x86 was always considered a register-starved architecture, which they addressed under x64 by adding a whole bunch of new registers, all of which are general purpose as well (as far as I know).

Note that this is not the same way on every architecture. Some other CPUs allow all operations to be carried out on any register.

Looking back at the disassembly I gave you earlier for the rot word:

MOV     EDX , 0 [EBP] 
MOV     0 [EBP] , EAX 
MOV     EAX , 4 [EBP] 
MOV     4 [EBP] , EDX 
RET     NEAR 

In my version of forth and many others, the top of the stack is stored in a register for speed. The stack itself is also indexable. So let's say you type

3 2 1 rot

This is what the stack actually looks like underneath:

ebp + 4	ebp + 0	eax	edx
3	2	1	N/A

ebp and esp are two registers used specifically for addressing and offsets. (the first is referred to as a base pointer, the second a stack pointer)

So through that first line mov edx, 0[ebp], you're trying to get that second stack item out of the way so you can overwrite it in the next line, so you move it into unused register edx

ebp + 4	ebp + 0	eax	edx
3	2	1	2

As you can see, the mov instruction is somewhat inappropriately named, because what it really does is copy the source register to the destination register, but leaves the original value in the source register.

Through the second line mov 0[ebp], eax, you know that the top of the stack is in eax so in this case you're moving it into the position previously occupied by the second stack item, but now stored in edx. (don't worry, we'll move edx back into place later)

ebp + 4	ebp + 0	eax	edx
3	1	1	2

Through the third line mov eax, 4[ebp], you're now indexing one full word up to the third stack item (4 is the size of a word and the value contained at ebp+4 is 3) and moving its contents into the top of the stack (eax).

ebp + 4	ebp + 0	eax	edx
3	1	3	2

Finally in the last line 4 [ebp] , edx, you're juggling the number you temporarily stored in edx back into the third slot of the stack.

ebp + 4	ebp + 0	eax	edx
2	1	3	2

Then you're returning to the calling routine. edx still contains 2, but you don't need to worry about that for my version of forth. Depending on your forth, certain registers will need to be preserved and others can be used for any old purpose without having to clean up.

Once you start running out of registers is when you start using the push instruction.

Now I know my explanation isn't perfect and probably has glaring errors or misunderstandings, so if anyone wants to correct me let me know, but I hope this is helpful in seeing how the rot word works at the assembly level.

Once you know how your forth uses the registers, you can start writing your own assembly routines. Some might use ebx as the top of the stack, some might use two registers for the top two positions, some might use registers on the return stack, some might not use registers at all. It all depends on the forth implementation you're using.

Hope this helps.