Low level language

A low-level or first generation feature programming language is one in which its instructions exercise direct control over the hardware and are conditioned by the structure physics of the computers that support it. The use of the word low in its name does not imply that the language is less powerful than a high-level language, but rather refers to the reduced abstraction between the language and the hardware.

Complexity vs. difficulty

Low-level languages such as assembly language can be more difficult to program than high-level languages because they are more closely related to the technical features of the hardware. In addition, these usually lack higher-level abstractions. An abstraction outside of what is stipulated for the microcode set of a computer microprocessor is not possible. On the other hand, it is more easily translatable into machine language, a task that is essentially performed by a compiler.

From the lowest to the highest level of abstraction with respect to the hardware, it is possible to classify programming languages as follows:

1. Machine language: It is composed of one (1) and zeros (0) that will directly execute the central processing unit (CPU). By visualizing this language in a plain text editor it will seem meaningless (raw characters). Many of them will be non-printable characters. These zeros and some represent literally instructions and data to be processed.
2. Assembly languages English assembler): Also called nemotechnic or nemonic, are a first level of abstraction. They are no longer executable programs directly on the computer, but human-intelligible source code texts that need some tool (esentially a compiler) for translation into machine language that the CPU can execute. Its instructions are usually an abbreviated denomination of the machine instruction that symbolize, and have almost direct correspondence (one to one) to the machine instructions they represent. The code resulting from the compilation of the assembly language generates an executable binary machine code.

   These are instructions that assemble the commuters groups necessary to express a minimum arithmetic logic. They are intimately linked to the hardware. Some of these instructions can be for example MOV to move a data from one place to another, or ADD to add two values. They are generally available at firmware, cmos or chip set level. These languages are process-oriented. The processes are composed of tasks. They contain as many instructions as the hardware architecture has been designed. The CISC architecture contains many more instructions at this level than the RISC.

   • For example: Assembler x86, JMP and MULT.

   The other languages that complete the classification would no longer be low-level languages.

3. Medium-level languages: These are those who, based on the available instruction games (chip set), allow the use of functions at arithmetic level, but at a logical level depend on verbatims in assembly. These languages are procedure-oriented. The procedures are composed of processes.

   • Examples: C, Basic. Highest level but still considerable medium level: C++, Rust, Fortran, Cobol, Lisp,Go.

Machine interaction

This type of language works at the instruction level, that is, its programming is down to the finest detail, and it is completely machine-oriented.

• Adaptation - Maximum programming and use of the machine resource.
• Speed - Maximum with direct access to resources, without intermediate layers.
• Portability - Minimum for being restricted to manufacturer specifications.
• Abstraction - Minimum to depend completely on the hardware technique.
• Use - Requires the utmost attention and a structured organization based on the hardware plans and the objective of the software.
• isomorphism - Conceptualization of information data, complemented

First generation

First generation programming language (1GL), is the language of machine code. It is the only language that a microprocessor understands natively. Machine language, as it consists of ones and zeros, is difficult to read and there is a high probability of making a mistake when entering it, therefore it is rare for a person to use it directly.

Instructions in machine language consist of one or two instruction memories, and other memories with data (see article addressing modes)

Second generation

The second generation programming language (2GL), is assembly language. The improvement with respect to the previous one is that instead of plain ones and zeros, you have mnemonics already written as a text, and data visible next to the mnemonic. This requires a program that translates the mnemonics into machine language.

An assembly language programmer must know the architecture of the processor (such as the particulars of its registers or its set of instructions).

Example of assembly code in the purple box. Below, in the red box is shown a codified text in hexadecimal in ASCII code.