🏵️ 🍐 🐐 Classification of programming languages 🏂🏾 🔍 👗

Programming languages are systems of symbols and their combination rules, designed for human interaction with complex machines. There are hundreds of such organized systems that perform various functions. To navigate this variety, specialists create general classifications of programming languages based on one or another characteristic feature.

Human-Machine Interaction

It is important to understand how people communicate with smart mechanisms before moving on to the classification of programming languages.

One day, a man thought that a machine could do the physical work for him. So there was a steam engine. Then the enterprising man decided to shift to the car also mental work. So computers appeared.

To achieve a result, you need to understand how to do it. In programming, there are several stages to solving any problem:

A formalized logical description of the task itself.
The construction of an algorithm that describes all the steps to achieve the goal, starting from processing the input data and ending with the receipt of the result.
Coding is the compilation of a program in any of the programming languages, which can then be translated into a computer-understandable language.
Broadcasting is a direct translation.
Assembling a working program (executable module) from all components.

This is a hierarchical structure in which the higher levels are based on the lower. Without a clear task and a competent study of the algorithm, it is impossible to create a high-quality program.

The structure of programming languages

The structure of all interaction systems is similar and largely determines the classification of programming languages.

The main objects of the programming language are constant and resemble the components of human language systems:

syntax defining formal rules for writing a program, valid types and case of characters;
vocabulary, which includes the entire vocabulary of the language: names of variables and functions, constants, strings, operators;
A grammar indicating how to combine language units to form phrases and sentences.

Vocabulary and grammar together define the semantics of a language. At this level, specific sequences of signs acquire a special meaning that is understandable to humans and computers. For example, the word while in many programming systems is interpreted as the beginning of a cyclic operation.

Of course, computers do not understand ordinary words; in itself, a combination of Latin letters means nothing to them. Machines deal with machine code — zeros and ones that describe primitive states of signal presence or absence. Therefore, programming languages establish clear correspondence between certain words and sequences of native machine instructions.

The first primitive machine control systems - punch cards - were used for Jacquard looms, which transferred a pattern of any complexity to silk. In the same way, self-playing pianos were programmed.

There are hundreds of programming systems, and new ones appear every year. Some of them are fundamentally different from each other, others are very similar and have only small features. Each is designed to solve its own problem, broad or highly specialized.

Classification Overview

Programming languages can be grouped in dozens of different attributes. They are fundamentally important or have applied value.

A strong dependence of the classification of programming languages on the history of development is observed. Over the years, technology has become more complex and dramatically changed, the convenience of a programmer has come to the fore, effective algorithms, complex commands, and new levels of abstraction have appeared.

The main classifications of programming languages by type and mechanism of work are based on the following parameters:

Features of vocabulary and grammar in conjunction with the level of abstraction and the degree of convenience for a person.
Basic concept and methodology for compiling algorithms.
The way data is presented.
Organization of the process of interaction with the machine, program execution mechanism.
The area of life in which the language is applied.
The historical era in which the language system was formed.

It is impossible to make a clear classification of programming languages and systems, but it is possible to separate and systematize them according to fundamentally important signs.

Convenience for man

Instructions written in machine language are understandable to the computer, but extremely inconvenient for humans. It is difficult to understand them, it is almost impossible to quickly change them or make up a complex algorithm with their help. To increase efficiency, programmers have risen to new levels of abstraction and taught the machine how to accept more human-readable instructions and translate them into machine code on their own. Consider the classification and features of programming languages of different levels:

Machine code. This is also a programming language in which, with proper preparation, you can write instructions.
Low level. Truly low-level are assembly languages that use native machine instructions encoded using mnemonic codes.
Middle level. The programming systems of this group can be considered both low- and high-level, depending on specific ideas about the degree of abstraction. These include C and C ++.
High level. These languages allow you to create complex algorithms, but require additional processing before execution, so the code generated by them is less efficient and runs slower.
Super high level. This small group is characterized by the emergence of super-powerful teams and operators. These include Algol-68.

A feature of low-level languages is their machine dependence. They are closely tied to the characteristics of the organization of a particular type of computer, but are generally similar to each other. They provide:

high speed of execution and maximum compactness of the created programs;
direct interaction with hardware resources;
full control over memory.

The main disadvantages of low-level languages:

for each type of computer, it is necessary to use a certain system of commands, depending on the features of the functioning of the machine;
complexity and low speed of the programming process;
a high probability of errors that are difficult to track;
lack of program mobility, inability to run them on a different type of computer.

High-level programming systems are not tied to a specific machine instruction system and can be executed on any computer. Due to the high level of abstraction, they can afford to use various concepts and methodologies in the preparation of instructions. Therefore, the classification of high-level programming languages is very extensive and complex.

Machine program processing

To execute a complex instruction, a computer must first of all reduce its abstractness and translate it into a language that is understandable to itself. The way this is done is called the execution model. There are two main models and one hybrid:

Compilation is a one-time translation of the entire program into machine code.
Interpretation is the sequential execution of each expression.
Transcompilation is a translation into a lower level language, such as C or assembler, and its subsequent compilation.

Translation requires a special translator program — a compiler or interpreter, without which working with the language is impossible.

The interpreter works with each line of the program separately, analyzing it and immediately executing it. His presence is necessary from the beginning to the very end of the program.

The main disadvantages of the interpretation model:

the constant presence of the translator in the computer memory;
reprocessing repeated commands.

Despite this, the interpreted languages are very convenient for cyclic development and debugging, as they allow you to quickly make changes to the program.

The compiler, however, only works once, immediately converting the entire instruction into a computer-friendly form — machine code or some intermediate bytecode — and then leaves the computer's memory. Here, execution is separate from the translation process, which is a more efficient model.

The main disadvantages of the compilation model:

great difficulty.

Before translating the program into a machine-understandable language, the translator goes through the original instructions many times, analyzing and checking it.

There is no clear distinction between systems, since traditionally interpreted languages can be compiled and vice versa.

Classification of high-level programming languages by execution model:

Interpreted - Python, Haskell, PHP, JavaScript.
Compiled directly into machine code: C, C ++, Fortran, ASM.
Compiled to bytecode: Python, Java.
Transcompiled: Haskell, Fortran, C, C ++.

Data processing

Any programming language works with information that needs to be somehow manipulated, checked for correctness, changed. Data can be very diverse - numbers, strings, or complex structures. Of course, it is necessary to work with each type in a different way, but in order to determine how, it is first necessary to understand what kind of data the computer is dealing with.

Based on the method of determining the type of data, a classification of programming languages by type system is constructed.

Untyped languages.
Typed languages of varying degrees of severity.

Untyped are assembly languages that are capable of processing binary data directly. The data type in this case does not matter.

For typed languages, what kind of data they work with is important. Some operations are defined only for numbers, for example division, others - only for lines. However, some systems allow the programmer certain liberties. For example, they can independently determine and "implicitly" convert one data type to another, based on the semantics of the command. This is very convenient, but complicates debugging, as it can lead to an imperceptible error. A prime example of loose typing is JavaScript.

Strictly typed languages, such as Java, do not allow such freedom and require specifying types and their explicit conversion, if necessary.

There is also a classification of high-level programming languages at the time of checking data types:

Static languages are usually compiled. Type checking occurs when analyzing a program before translating it into machine language.
dynamic languages check data types at runtime.

The principal way of interaction

Highly abstract languages can be divided according to the main programming paradigm. There are dozens of programming methodologies, some of which are very similar to each other, so creating a clear system of differences is impossible. Briefly, the classification of programming languages looks like this:

algorithmic, imperative, procedural. They require an explicit consistent description of the algorithm for solving the problem. At the same time, operators are combined into procedural groups that are separate from the data itself. Examples of procedural languages - Pascal, Basic;
logical, declarative. The task itself and the desired result are described as formally as possible. The solution should logically follow from this description;
object oriented, structured. They are based on the concept of an object that combines data and methods of processing them.

Objects in programming

The languages of the latter group describe all entities in the form of independent objects that hide complex mechanics. The main concepts of OOP (object-oriented programming) are:

encapsulation - hiding the functionality inside the object;
inheritance by some objects of methods of others;
polymorphism - a change in essence while maintaining the external interface.

You can also make a classification of object-oriented programming languages by the method of implementing the basic concepts of this approach - inheritance, encapsulation and polymorphism. In addition to the classical mechanisms, there are others, for example, the prototype used in JavaScript.

The OOP methodology is considered the most progressive, effective and, in a sense, fashionable. However, in some cases, other approaches, for example, functional, may be more effective for solving a specific problem.

Generations of programming languages

The classification of programming languages according to the history of their appearance is considered conditional, since it does not take into account the features of specific systems. However, it allows you to trace how the concepts have changed over time and the tasks facing programmers have become more complicated.

In attempts to connect the classification and evolution of programming languages, several large groups, called generations, stood out:

The first generation - low-level machine languages, tied to the implementation of a particular computer. "Programs" in these languages looked like rows of switches brought to the desired position, or punched cards (punched tapes). Thus, all commands were a sequence of zeros and ones - a binary code. Example: ARM processor language.
In the second generation, languages have become a little clearer for humans, but failed to untie them from a specific device. This is the time of assembly languages with its mnemonic codes and unambiguous assembly in machine-readable form. Example: Macroassembler.
Third-generation languages removed the programmer’s concern for the unprincipled details of compiling instructions, such as translating a program into machine code. Now the computer has learned to do it on its own. Syntax and vocabulary are closer to human, became more understandable. In this generation, almost all modern high-level languages with a wide scope were born, regardless of their paradigm: PHP, Fortran.
In the fourth generation, the level of abstraction increased even more, sharply narrowing the scope of use. This group includes such specific languages as FoxPro, Simulink, SQL. Visual programming languages appeared: CAD packages, RAD systems .
Finally, fifth-generation languages had to write programs themselves, receiving only a description from the programmer. This idea was never fully realized, since direct machine logic is sometimes not enough to compose an effective algorithm, and human intuition and ingenuity are also required. Examples of fifth generation languages are MathCAD, Prolog, and Mercury.

In fact, generations of languages correspond exactly to the programming steps discussed at the beginning of the article, listed in reverse order. Initially, the programmer took over all the operations, and the machine only performed the specified sequence of actions. Now the computer is able to produce a result according to a formalized description of the problem.

Facilitating the work of a programmer is accompanied by an increase in the load on the machine, the program runs more slowly and requires large resources.

Despite the fact that technological progress is moving by leaps and bounds, the languages of the first generations have not disappeared at all. They are used in areas requiring maximum simplicity and efficiency.

Application area

Each programming language is good in the field for which it was created. So, assemblers are used to program microcontrollers, and there is nothing to do with Java there. Low-level driver programming is effective with C, which allows you to strictly control memory resources. For web programming, you should choose the scripting languages PHP and JavaScript, the interpreter of which is built into every modern browser. Important banking programs are written in Java, which provides error control. Aerospace - also in Java or Pascal, which even gives the garbage to the control of the programmer.

All languages are good, you just need to choose the appropriate task.

The importance of classification

It is difficult to divide hundreds of existing systems of human-computer interaction into several distinct groups. Nevertheless, a review of classifications of programming languages briefly traces the history of their evolution and reveals the ideas embedded in them more deeply.

Each language simultaneously belongs to several of the listed groups - it can be strictly typed, compiled and object-oriented at the same time. Therefore, one cannot consider the diversity of programming systems through the prism of any one classification.

Classification of programming languages