When I first started programming I remember seeing a table with the amount of memory that each variable would take up for instance a byte would take up a byte, a short would take up two bytes, and an int would take up four bytes. Now any enthusiastic programmer (I did this so it may just be me) would immediately think I’m going to make my program take up as few bytes of memory as possible which is a noble idea. They will go through their program and determine the range of each variable and then figure out at most how many bytes they will need. However, this approach may be quite flawed for the following reason: once your compiler converts your high level language that you’re using into machine code you end up using more processor cycles to achieve the result. This is due to the nature of numbers inside of memory and the processor. Inside a processor you cannot add two variables if they differ in size so you must convert one to the size of the other by loading it into the A(al,ax,eax for 1byte,2byte, and 4byte respectively) register of the appropriate size and converting it (2 cycles where it should take one cycle)

Take the following example for instance: [Written in Java]
byte x = 6;
short y = 32;
int z= 128;

int v = x+y+z;

the same process in x86 assembly would look like this:
.data
x byte 6
y word 32
z dword 128
v dword ?
.code
mov al,x
cbw
add ax,y
cwde
add eax,z
mov v,ax

Now lets take a look at the processor optimized solution: [Java]
int x = 6;
int y = 32;
int z= 128;

int v = x+y+z;

And in x86 assembly:
.data
x dword 6
y dword 32
z dword 128
v dword ?
.code
mov eax,x
add eax,y
add eax,z
mov v,ax

You see in the processor optimized solution there are only four total operations to carry out in the memory optimized solution though there are six total operations. It might not seem like much but imagine you have to do this operation ten thousand times. The processor optimized solution takes only 60% of the operations that the memory optimized solution takes and it only uses five more bytes of memory. That’s a huge time savings no matter how you look at it.

Now I’m not saying the processor optimized solution is always the best solution. Instead I’m saying that in a system where you don’t have to worry too much about memory management that a processor optimized solution my make your program run faster. If you’re in a system with limited memory though it’s probably faster to just go ahead and optimize it for memory since the conversion operations are pretty fast anyways. It’s worth it to note I’m just a student so if I’ve misunderstood some concept please correct me I’m just trying to learn all I can.