Assembly Language

What Is an Assembly Language?

An assembly language is a type of low-level programming language that is intended to communicate directly with a computer’s hardware. Unlike machine language, which consists of binary and hexadecimal characters, assembly languages are designed to be readable by humans.

Low-level programming languages such as assembly language are a necessary bridge between the underlying hardware of a computer and the higher-level programming languages—such as Python or JavaScript—in which modern software programs are written.

How Assembly Languages Work

Fundamentally, the most basic instructions executed by a computer are binary codes, consisting of ones and zeros. Those codes are directly translated into the “on” and “off” states of the electricity moving through the computer’s physical circuits. In essence, these simple codes form the basis of “machine language,” the most fundamental variety of programming language.

Of course, no human can construct modern software programs by explicitly programming ones and zeros. Instead, human programmers must rely on various layers of abstraction that can allow themselves to articulate their commands in a format that is more intuitive to humans.

Specifically, modern programmers issue commands in so-called “high-level languages,” which utilize intuitive syntax such as whole English words and sentences, as well as logical operators such as “and,” “or,” and  “else” that are familiar to everyday usage.

Ultimately, however, these high-level commands need to be translated into machine language. Rather than doing so manually, programmers rely on assembly languages whose purpose is to automatically translate between these high-level and low-level languages. The first assembly languages were developed in the 1940s, and though modern programmers and modern natural language processors spend very little time dealing with assembly languages, they nevertheless remain essential to the overall functioning of a computer.

Components of Assembly Language

Syntax

When writing any code in any program language, there is an observable, specific order of rules that must be followed to allow a compiler to execute the code without error. These rules are defined as the syntax, and they contain criteria such as the maximum number of allowable characters, what characters code lines must start with, or what certain symbols "i.e. a semi-colon" means.

Label

A label is a symbol that represents the address where an instruction or data is stored. It's purpose is to act as the destination when referenced in a statement. Labels can be used anywhere an address can be used in assembly languages. A symbolic label consists of an identifier followed by a colon, while numeric labels consist of a single digital followed by a colon.

Operators

Also referred to as commands, operators are logical expressions that occur after the label field. In addition, it must be preceded by at least one white-space character. Operators can either be opcode or directive. Opcode correspond directly to machine instructions, and the operation code includes any register name associated with the instruction. Alternatively, directive operation codes are instructions known by the assembler.

Directive

Directives are instructions to the assembler that tell what actions must take place during the assembly process. Directives have the importance of declaring or reserving memory for variables; these variables can be recalled later in processes to perform more dynamic functions. Directives are also used to break programs into different sections.

Macro

An assembly language macro is a template shoe format presents a series or pattern of statements. This sequence of assembly language statements might be common to multiple different programs. A macro facility is used to interpret macro definitions, while a macro call is inserted into the source code where "normal" assembly code would have gone instead of the macro set of statements.

Mnemonic

A mnemonic is an abbreviation for an operation. A mnemonic is entered into the operation code for each assemble program instruction to specify a shortened "opcode" that represents a larger, complete set of codes. For example, the mnemonic "multiply by two" has a full set of code that carries out the mnemonic.

High-Frequency Trading

Today, assembly languages remain the subject of study by computer science students, in order to help them understand how modern software relates to its underlying hardware platforms. In some cases, programmers must continue to write in assembly languages, such as when the demands on performance are especially high, or when the hardware in question is incompatible with any current high-level languages.

One such example that is relevant to finance are the high-frequency trading (HFT) platforms used by some financial firms. In this marketplace, the speed and accuracy of transactions is of paramount importance in order for the HFT trading strategies to prove profitable. Therefore, in order to gain an edge against their competitors, some HFT firms have written their trading software directly in assembly languages, thereby making it unnecessary to wait for the commands from a higher-level language to be translated into machine language.

Advantages and Disadvantages of Assembly Language

Assembly language can usually be executed faster than high level languages. It's relatively easy to insert of delete components of assembly language code, and assembly language usually requires fewer instructions to complete a task when compared against other types of languages.

Assembly languages are also often used by programmers wanting greater control over their computers as assembly languages allow you to directly manipulate your hardware. Because of its speed and importance, some programs are specifically written using assembly language as the code can usually remain smaller.

Assembly languages do tend to have several drawbacks. Long programs written using assembly language usually require heavier computing power and can not be run on small computers. Some may find the syntax of assembly language more difficult to remember, and it may take some longer to code using assembly language as it is more complex. In addition, assembly language is usually not portable between different makes of different computers; similar to how employee benefits are lost when switching companies, languages cannot be seamlessly translated to different computers.

Types of Assemblers

Assembly language must be translated into machine language using an assembler. There are two primary types of assemblers.

A single-pass assembler scans a program one time and makes an equivalent binary program. This type of assembler validates assembly language code by looking the code up in a mnemonic code table. A single-pass assembler is often faster than a multi-pass assembler, and there is usually no need to construct any intermediate code.

A multi-pass assembler means the assembler uses more than one pass. Multi-pass assemblers create a table with every symbol and each of their values in the first pass, then use the table in future passes to generate new code. Each separate pass usually handles a different specific task. Though usually slower, multi-pass assemblers with modular structures can often be reused for different machines.

Example of Assembly Language Code

Below is an example of Netwide Assembler (NASM) assembly language code.

In this example, the SYSCALL instruction towards the end of the code triggers the portion of memory where the operating system services are stored. Then, the code RAX is used to call for code to be written, then RDI to exit. The SYSCALL function is used twice to invoke the operating system as well as to indicate to the system when the code is finished and it is time to exit.

The Bottom Line

Assembly language is low-level code that relies on a strong relationship between the instructions input using the coding language and how a machine interprets the code instructions. Code is converted into executable actions using an assembler that converts input into recognizable instructions for the machine. Though prevalent in the early days of computing, many larger systems use higher-level languages.