Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Learn about Assembly languages and their role in computer architectures.

Assembly Language

Arithmetic operations make up the majority of functions in the Assembly languages. 

After all, the manipulation of binary numbers is how you execute any type of code, whether that be changing a character from lowercase to upper case or turning a pixel on a screen from red to blue.

One of the most important aspects of mathematical operations is how numbers are stored at the machine hardware level. Memory locations, such as registers, cache, or secondary storage, all have fixed binary lengths.

These fixed lengths mean that processors must have special registers to “catch” overflow from operations. Overflow operations can include handling extremely large numbers, marking when a carryover occurs in addition or storing both the quotient and remainder of division operations.

Most languages allow for at least two distinct types of each arithmetic operation. One type performs a calculation on two registers and the other performs an operation using one value from a register and another value that is directly added, known as an immediate or constant.

The addition calculation for example can be called using the `ADD` opcode which then takes three registers as operands, two registers to add together and another to store the answer in.

The addition function also has an `ADDI` command, which takes a register address and a constant to operate on and a register to store the answer in.

In the `ADD` function, the value in $5 is added to the value in $4 and stored in $6.
```
ADD $4, $5, $6
```

In the `ADDI` function, the constant 7 is added to the value in $4 and stored in $6
```
ADDI $4, $6, 7
```

Other common arithmetic operations include: `SUB`, `SUBI`, `MULT`, `MULTI`, `DIV`, and `DIVI`.


Arithmetic Operations

An important step in the journey to execute code is Assembly.

The process of code execution starts with a software developer creating a program in a high-level programming language, such as Python or Java, that was designed to be easily read and understood by humans.

For a computer to execute this program, the code must be simplified into binary. In our humble beginnings, programmers initially coded in binary; then, Assembly was created to make it easier for humans to program.

Assembly is a low-level programming language used to directly translate instructions into the computer's machine code in a more human-readable way. Similar to machine code, each instruction begins with an opcode and then references memory locations or data types to operate on.

Understanding Assembly is an essential skill on the path to becoming a professional software developer. Studying Assembly allows us to “get under the hood” of our typical programs, making better decisions when it comes to data storage, algorithm optimization, and hardware interactions.


Python code goes down an assembly line. After going through a machine, the Python code is converted to Assembly. The Assembly code then goes through another machine and is converted to binary.

Introduction to Assembly Languages

In Assembly, we use branches and jumps to provide control flow in our programs.

A _branch statement_ is used to define a conditional statement. Think of it as a fork in a river. We are sitting in our kayak and trying to make a decision. If something is true, take the fork on the left; if it’s not true, take the fork on the right.

Since we are dealing with binary values, most branching operations center around arithmetic operations and their results.

There are two primary ways we branch:
- On equality
 - `BEQ` (Branch on Equal)
 - `BNE` ( Branch on Not Equal)
- On reference to zero
 - `BGTZ` / `BGEZ` (Branch on > zero / Branch on ≥ zero)
 - `BLTZ` / `BLEZ` (Branch on < zero / Branch on ≤ zero)

The other way we can control the flow of our program is to jump directly to a specific instruction using a _jump statement_, followed by the memory location that contains the instruction. This is similar to making function calls or returning back out of a function.

- Jump to Register 31 and execute the instruction stored there:
```
J $31
```

In Assembly, we jump to a memory location and execute the code stored there as its own binary instruction. This can start a separate subroutine or simply perform the function of starting a loop over.

Control Flow Operations

You may have noticed the use of dollar signs and parentheses in our previous code. These are some MIPS language conventions used to denote direct and indirect memory referencing.

Let’s assume that Register 5 has the value `1101000111`2 (83910) stored in it. Let us also assume that there is a piece of memory with the address 839 that contains the value `1000111000111`2 (455110).

When we directly reference something in memory, we are telling the assembler that we want the value that is stored in that exact location.

Let's take a look at an Assembly code example that adds the value of Register 5 to Register 5 and saves the result in Register 6:
```
ADD $5, $5, $6
```
Register 6 now contains `11010001110`2 (167810). 839 + 839 = 1678

When we indirectly reference memory, we are telling the assembler that we don’t want to use the value of what is stored in the reference, we want to use that value as the address to another memory location and use the value stored there. 

```
LW $4, ($5)
ADD $5, $4, $6
```

In MIPS we can only perform operations on registers so the first step is to retrieve the value from memory with the Load Word statement and save it into Register 4. When we use the parentheses around Register 5, we are now telling the assembler to go and find the data that is stored in the memory address 839 which was `1000111000111`2 (455110).

At the conclusion of our `ADD` statement, Register 6 now contains the value `1010100001110`2 (539010). 4551 + 839 = 5390.

Memory Addressing: Direct and Indirect

Memory access and the control of stored information is an incredibly powerful aspect of Assembly while also being one of the most confusing.

As we write Assembly, we control exactly where every piece of information is stored. This means it is on us to choose if a value is stored in a register for immediate use or in alternate memory to be loaded from later.

In the MIPS Assembly language, all calculations are performed exclusively on registers. Since we are limited on the number of registers we have, when we no longer need to use data right away we push it back into memory to access later.

The statements that provide these push and pull operations are `LW` and `SW`, which stand for `LOAD WORD` and `STORE WORD`. 

A _word_ is a fixed length of data defined by the ISA. In the MIPS32 architecture that we have been using, a word is a 32-bit value.

In this example we will load a number value from memory, add `15` to it, and save it back to memory:

1. `LW` loads the value stored in the memory address of Register 3 into Register 1
```
LW $1, ($3)
``` 
2. `ADDI` adds the value of Register 1 and the constant, `15`, and stores the result in Register 1
```
ADDI $1, $1, 15
```
3. `SW` stores the value in Register 1 to the memory address of Register 3
```
SW $1, ($3)
```
4. `XOR` is used to store zero in Register 1, essentially resetting the register.
```
XOR $1, $1, $1
```

Unlike high-level languages, in Assembly, it is the programmer’s responsibility to remember where pieces of data are stored and ensure not to overwrite it. Registers are limited and memory takes time to access, so it is a careful balancing act of keeping data available or pushing it deeper into memory.


Memory Access Operations

The generated Assembly from the last exercise follows much of the same semantics as the machine code we learned in the ISA lesson. This is because Assembly language and binary code have almost a direct translation between their outputs.

Assembly was created as a mnemonic language to make machine code easier to read and write, one instruction translating to one instruction. In fact, most ISAs will have both the binary code and Assembly language breakdown on the same page when talking about specific instructions. 

Just like in binary, Assembly begins with an opcode. Luckily for us, the opcodes are much more readable than a bunch of `0`’s and `1`’s. Let’s take a look at the multiply function:

Assembly:
```
MULT $3, $2
```

Binary:
```
00000000111001100000000000011000
```
It's easy to see how much easier it is to write a program in Assembly than to write it in binary. In most Assembly instructions, what follows the opcodes are the memory locations to be operated on. These memory locations are referred to as operands. Generally, these are direct register addresses but can also be memory references to values stored in other types of memory such as the cache or RAM. 

In MIPS, direct register addresses begin with the `$` symbol, so in our `MULT` example, we are multiplying the value stored in register `$2` by the value in register `$3`. You can learn more about MULT and other MIPS functions in the official [MIPS32 Documentation](https://s3-eu-west-1.amazonaws.com/downloads-mips/documents/MD00086-2B-MIPS32BIS-AFP-6.06.pdf).

Assembly Code Format

Before we dive too deep into Assembly language, let’s take a step back and learn where Assembly language fits into the everyday process of software engineering.

When we push **Run** in our code editor, the computer is performing a number of tasks in the background before the computer hardware even gets to see its first bit of binary code.

In general, there are four steps, known as the Compilation Process, that make up the journey high-level code goes on before reaching the hardware:

- **Preprocessing** is the first step of compilation and is used to prepare the user’s code for machine code by removing comments, expanding included macros, and performing any code maintenance prior to handing the file to the compiler.
- **Compiling** is the process of taking the expanded file from the preprocessor and translating the program into an optimized Assembly language.
- **Assembling** is the process of taking an assembly language program and using an assembler to generate machine code.
- **Linking** is the process of filling in function calls, including additional objects, libraries, and source code from other locations into the main source code.

While the compilation process is tailored to each language and architecture, the overall procedure is fairly standard. It is in the compiling and assembling stages where Assembly is generated and used to create machine code.


Compilation Process

Assembly was written as the first language above binary to make it easier for humans to write functional programs. As such, there is almost a line for line equivalency between the two codes.

When we first translated the simple `square()` method to Assembly in Exercise 3, our two lines of Python code expanded into 16 lines of Assembly. The code editor has the Python and the translated Assembly in the window to the right.

When the Assembler translates the Assembly code into machine code, each line will create a 32-bit MIPS instruction in accordance with the standards of the ISA.

The Assembly `ADD` function and the binary `ADD` function are structured the same way in the documentation in order to give developers better control over their programs.


Translation between Assembly and Binary

While Assembly has been mostly abstracted away from the lives of the majority of programmers, it still has a few specific use cases throughout the industry such as:

- Embedded systems that have limited memory and hardware capacity
- Direct hardware testing
- Software optimization

Embedded systems, along with their microcontrollers, are very often programmed in Assembly because it gives programmers the ability to control hardware functions on a task by task level, ensuring the size and speed of the program maximizes hardware limits.

A refrigerator, for example, has limited storage and computing capacity. Programming in Assembly ensures that both are used to their full potential.

Learning an Assembly language can give a programmer the idea of the “cost of code”. Certain algorithms can be optimized based on data storage and memory access techniques. Understanding how hardware implements these techniques can help a programmer choose the right tools for the right job and develop superior code.

Small optimizations in programs might not seem incredibly important with our advances in processing power, but in some cases, they can make all the difference. For example, if we are trying to achieve as near to real-time analysis as we can get, say to predict market swings in the stock market, things as trivial as the bit-space taken up by an integer can make a huge difference at run-time.

There are several Assembly languages, each written for a specific processor, or more precisely, in accordance with a processor’s Instruction Set Architecture. Three primary industry competitors are the x86, ARM, and MIPS architectures, which account for the majority of desktop, mobile, and embedded technologies respectively.

While we won’t master a specific Assembly language in this lesson, the goal that remains is to understand how Assembly language works on a fundamental level in order to write better software.


Three computer screens display the names of different ISAs. They are labeled MIPS, x86, and ARM, respectively.

Modern Assembly Applications

Congratulations on making it through the Assembly Language lesson!

Assembly languages play an important role in understanding how computer programs execute at the hardware level. Seemingly simple operations like our `square()` function actually require many more steps when translated into individual processor tasks.

Learning how these larger programs increase or decrease a processor’s workload can significantly affect the performance of a program.

As we write in a high-level programming language, our code leaves our editor and executes the steps of the compilation process in order to make our code functional.

Most of this process has been abstracted for general software developers but can still be accessed in order to optimize specific portions of your program. The translation to Assembly is one of the steps code takes on its journey to your computer hardware.

While first written to make it easier for early programmers to write code, Assembly now primarily serves the purpose of testing hardware applications or providing precise control of limited capacity embedded systems.

Assembly languages very closely mimic the machine code and ISAs will show references to both Assembly and Binary instructions when defining functionality.

Instructions always start with an opcode that defines the operation to be performed and follows that with the operands, or memory locations, to be operated on.

Some of the basic types of operations that make up an Assembly program are:

- Arithmetic (Add/Subtract)
- Memory Access (Load / Store)
- Control Flow (Branch/Jump)


Binary code being delivered to the computer hardware via an Assembly truck.