Low-level programming language

In computer science, a low-level programming language is a language that provides little or no abstraction from a computer's microprocessor. The word "low" refers to the small or nonexistent amount of abstraction between the language and machine language; because of this, low-level languages are sometimes described as being "close to the hardware."

A low level language is one that does not need a compiler or interpreter to run. The processor for which the language was written would be able to run the code without the use of either of these.

By comparison, a high-level programming language isolates the execution semantics of a computer architecture from the specification of the program, making the process of developing a program simpler and more understandable.

Low-level programming languages are sometimes divided into two categories: "first generation", and "second generation".

First generation

The first-generation programming language, or "1GL", is machine code. It is the only language a microprocessor can understand directly. Currently, programmers almost never write programs directly in machine code,Fact|date=July 2008 because not only does it (like assembly language) require attention to numerous details which a high-level language would handle automatically, but it also requires memorizing or looking up numerical codes for every instruction that is used. For this reason, second generation programming languages abstract the machine code one level. Example: A function in 32-bit x86 machine code to calculate the nth Fibonacci number:

8B542408 83FA0077 06B80000 0000C383FA027706 B8010000 00C353BB 01000000B9010000 008D0419 83FA0376 078BD98BC84AEBF1 5BC3

econd generation

The second-generation programming language, or "2GL", is assembly language. It is considered a second-generation language because while it is not a microprocessor's native language, an assembly language programmer must still understand the microprocessor's unique architecture (such as its "registers" and "instructions"). These simple instructions are then compiled directly into machine code. The assembly code can also be abstracted to another layer in a similar manner as machine code is abstracted into assembly code.

Example: The same Fibonacci number calculator as above, but in MASM assembly language:

fib: mov edx, [esp+8+1] cmp edx, 0 ja @f mov eax, 0 ret @@: cmp edx, 2 ja @f mov eax, 1 ret @@: push ebx mov ebx, 1 mov ecx, 1 @@: lea eax, [ebx+ecx] cmp edx, 3 jbe @f mov ebx, ecx mov ecx, eax dec edx jmp @b @@: pop ebx ret

ee also

* High-level programming languages
* Very high-level programming languages
* Categorical list of programming languages