Material from Wikipedia
Programming language- a formal sign system designed to record computer programs. A programming language defines a set of lexical, syntactic, and semantic rules that define appearance programs and actions that the performer (usually a computer) will perform under its control.
The first major breakthrough was the abstraction provided by assembly language, and with it the birth of the first automatic tools for generating machine code. This has reduced trivial errors, such as the number that corresponds to the operation, which are extremely cumbersome and difficult to detect, but easily fixed.
It should be noted that there are languages that combine high-level and low-level characteristics. The language has been designed with the following features in mind. The philosophy of object-oriented programming is different from conventional programming. Insurance. There are many restrictions, especially for applets, that limit what you can and cannot do with critical computer resources. Portable. Regardless of architecture. In the same way this code is interpreted different computers, you only need to implement an interpreter for each platform. Multithreaded. A language that supports multiple threads is a language that can execute different lines code at the same time. Interpreted. Dynamic. Note: machine code is binary code that the computer understands and can execute.
At the same time, in the 1940s, electric digital computers appeared and a language was developed that can be considered the first high-level programming language for computers - Plankalkül, created by the German engineer K. Zuse in the period from to 1945.
Next example. The first two types of comments are those that every programmer knows and uses in the same way. These comments serve as a description of the declared element, which allows us to generate documentation for our classes, written at the same time as the code is generated. In this type of documentation comment, you are allowed to enter some tokens or keywords, which will cause the following information to look different than the rest of the documentation.
Identifiers of names of variables, functions, classes and objects; whatever the programmer needs to define or use. The following characters can be letters or numbers. Capitalization is case sensitive and there is no maximum length. They will be valid identifiers.
From the mid-1950s, third-generation languages such as Fortran, Lisp, and Cobol began to appear. Programming languages of this type are more abstract (they are also called "high-level languages") and universal, they do not have a rigid dependence on a specific hardware platform and the machine instructions used on it. A high-level language program can be executed (at least in theory, in practice there are usually a number of specific versions or dialects of the language implementation) on any computer that has a translator for this language (a tool that translates the program into the machine language, after which it can be executed by the processor).
Not the entire "tree" of a directory is made up of user directories. There are many that are commonly used or have their own system and that they should be familiar with. The root from which they all "hang". This is perhaps the most important directory. It contains data files and system configuration, password file, terminal configuration, network, etc.
Interim fix directory. The first section contains all the headings. As the second section we have functions. Declaring functions occupied at the beginning of the program, it is possible that the main function is before the rest of the functions. When a program is executed, the first thing that gets executed is this function, and from there the rest of the program follows. Wirth designed this language to be a good first programming language for people starting to learn how to program. Pascal has a relatively small number of concepts to learn and learn from.
Updated versions of the listed languages are still in development. software, and each of them had a certain influence on the subsequent development of programming languages. Then, in the late 1950s, Algol appeared, which also served as the basis for a number of further developments in this area. It should be noted that the format and use of early programming languages was largely influenced by interface constraints.
Its design makes it easy to write programs using a style that is generally considered good standard programming practice. Another one of Wirth's design goals is easy implementation. He developed a language for which it would be easy to write a compiler for a new type of computer.
A program is a sequence of instructions. The process of executing these instructions is called running the program. Programs contain input, processing, and output functions. A person who solves problems by writing programs on a computer is known as a programmer. After analyzing the problem and developing a plan to solve it, write and test a program that instructs the computer to carry out the plan. The procedure performed by the programmer is defined as "problem solving". But it is necessary to point out that the programmer and the user are not the same.
Perfection
Visual (graphic) programming languages are becoming an important area of work, in which the process of “writing” a program as text is replaced by the process of “drawing” (designing a program in the form of a diagram) on a computer screen. Visual languages provide visibility and better perception of program logic by a person.
The user is the one who uses the program. Calculator example. Tanenbaum. The server just tried it a few days ago and was pleasantly surprised. Because the floppy disk only stores 44 megabytes of data, you can't use the same core as the floppy disk. Then run the following command from the directory.
Customize only what you really need. Your choices may vary depending on what you choose to include. Now enter the following command. Compression of the last kernel. Filesystem: It's not just a collection of files. Now we have to create a file system for the floppy disk. Instead of copying the files, since they are directly on the floppy disk, we compress them before copying them. It will be a little harder to change everything permanently. First enter the following.
Standardization of programming languages
International standards have been created for many widely used programming languages. Special organizations regularly update and publish specifications and formal definitions of the corresponding language. Within the framework of such committees, the development and modernization of programming languages continues and issues are resolved on the expansion or support of existing and new language constructs.
Where is the "place" on the hard drive where you are going to decompress the file system. Then we have to mount this file system that we have created. To do this, you need to compile your machine's kernel with the option. Either as a module or in a single core. Don't forget to restart your computer if you need to recompile the kernel! Now you should copy all the files you need to the new file system.
To do this, we must compress the file system by entering the following commands. Now it is important to check the kernel size. Then divide the core size between. In the future, replace in the orders that are displayed for the total kilobytes you have calculated. Now copy the kernel to a floppy using the following command.
Data types
Modern digital computers are binary and data is stored in binary (binary) code (although implementations in other number systems are possible). This data typically reflects real-world information (names, bank accounts, measurements, etc.) representing high-level concepts.
This command will write the kernel to a floppy disk. Then enter the following command so that the kernel can find the file system root on the floppy disk. Now you will need to do a little hexadecimal calculation. Finally, enter the following copy to copy the file system to the floppy disk.
Root file system will be copied to the floppy disk immediately after the kernel. You already have it! For the second floppy, the process is simpler. Copy the files you want to a floppy disk. However, in order to use the files on the second disk, after booting from the floppy disk, you will need to enter the following.
A special system by which data is organized in a program is type system programming language; the development and study of type systems is known as type theory. Languages can be divided into static typing And dynamic typing, and untyped languages(For example, Forth).
When we abstract opcodes and replace them with a word that is the key to its meaning, which is usually called a mnemonic, we have the concept of assembly language. Thus, we can simply define assembly language as follows. Assembly language is the first machine language abstraction, consisting of association with code code keywords that make it easier for the programmer to use.
As you can see, assembly language is directly translated to machine language, and vice versa; it's just an abstraction that makes it easier for people to use. On the other hand, the computer does not directly understand assembly language; it needs to be translated into machine language. Initially, this process was done manually using worksheets where the program tables were written in a similar way to the calculator example we saw above. But, because the translation was so direct, assembly programs soon appeared, which are translators that convert source into object code.
Statically typed languages can be further subdivided into languages with mandatory declaration, where every variable and function declaration has a mandatory type declaration, and languages with inferred types. Sometimes dynamically typed languages are called latently typed.
Data Structures
Type systems in high-level languages allow the definition of complex, composite types, so-called data structures. Typically, structural data types are formed as the Cartesian product of base (atomic) types and previously defined composite types.
For example, we can mention three completely different languages, which, nevertheless, start from the application of the previous concepts. We have 3 different manufacturers, competing with each other and each of which applies different concepts in the production of its processors, its architecture and programming; all these aspects affect the fact that machine language and assembly language change a lot.
The process of evolution has led to some disadvantages, which we will now see as the advantages of using assembly language in relation to a high-level language.
- Speed.
- size efficiency.
- Flexibility.
Basic data structures (lists, queues, hash tables, binary trees, and pairs) are often represented by special syntax constructs in high-level languages. Such data is structured automatically.
Semantics of programming languages
There are several approaches to defining the semantics of programming languages.
- Programming time.
- Excellent source programs.
- Risk of unexpected impact on resources.
- Lack of portability.
From there came compilers that are much faster than interpreters because they do the translation once and leave behind object code that is already machine language and can run very fast. Although the translation process is more complex and costly than assembling the program, we can generally neglect it, in contrast to the benefits of coding the program faster.
The most widespread varieties of the following three: operational, derivational (axiomatic) and denotational (mathematical).
- When describing semantics within the framework operational approach, the execution of programming language constructs is usually interpreted with the help of some imaginary (abstract) computer.
- Axiomatic semantics describes the consequences of executing language constructs using the language of logic and setting pre- and postconditions.
- Dental semantics operates with concepts typical of mathematics - sets, correspondences, as well as judgments, statements, etc.
Programming paradigm
A programming language is built according to one or another basic computing model and programming paradigm.
Most of the time, however, the code generated by the compiler is less efficient than the equivalent code the programmer would have written. The reason is that the compiler doesn't have much intelligence, and it must be able to produce generic code that serves both one program and another; instead, the human programmer can take advantage of the specific characteristics of the problem, reducing generality, but at the same time not wasting any instruction, doing any process that is not necessary.
Therefore, when program speed is critical, Assembly becomes a logical candidate for a language. Therefore, it is recommended to first optimize these aspects on desired language and use Assembler only when more optimization is required and cannot be achieved by these means. For the same reasons we saw in terms of speed, compilers and interpreters generate more machine code than is necessary; That's why executable program is growing. Thus, when it is important to reduce the size of the executable while improving memory usage as well as gaining speed advantages, it can be convenient to use assembly language.
Despite the fact that most languages are focused on the imperative model of computing, given by the von Neumann computer architecture, there are other approaches. We can mention languages with a stack computing model (Forth, Factor, PostScript, etc.), as well as functional (Lisp, Haskell,,, REFAL, based on the computing model introduced by the Soviet mathematician A. A. Markov Jr., etc.) and logic programming (Prolog).
Among the programs that require minimal memory usage, we have viruses and device drivers. Many of them, of course, are written in assembly language. The above reasons are to some extent: we can do things in a different language, but we want to do them more efficiently. But all high-level languages have control limitations; making abstractions, limit their abilities. That is, there are tasks that a machine can perform, but a high-level language does not allow. However, in assembler it is very simple because we have direct access to the monitor hardware.
Currently, declarative and visual programming languages are also actively developing, as well as methods and tools for developing problem-specific languages (see Language-Oriented Programming).
Ways to Implement Languages
Programming languages can be implemented as compiled, interpreted, and embeddable.
A program in a compiled language is converted (compiled) into machine code (a set of instructions) with the help of a compiler (special program) for of this type processor and further assembled into an executable module, which can be launched for execution as separate program. In other words, the compiler translates the source code of the program from a high-level programming language into binary codes of processor instructions.
If the program is written in an interpreted language, then the interpreter directly executes (interprets) the source text without preliminary translation. The program remains in its original language and cannot be run without an interpreter. The processor of a computer, in this connection, can be called an interpreter for machine code.
The division into compiled and interpreted languages is conditional. So, for any traditionally compiled language, such as Pascal, you can write an interpreter. In addition, most modern "pure" interpreters do not execute language constructs directly, but compile them into some high-level intermediate representation (for example, with variable dereference and macro expansion).
For any interpreted language, you can create a compiler - for example, the language Lisp, originally interpreted, can be compiled without any restrictions. Code generated at runtime can also be dynamically compiled at runtime.
As a rule, compiled programs run faster and do not require additional programs to execute, since they are already translated into machine language. At the same time, each time the program text is changed, it needs to be recompiled, which slows down the development process. In addition, a compiled program can only run on the same type of computer, and usually under the same operating system, for which the compiler was designed. To create an executable for a different type of machine, a new compilation is required.
Interpreted languages have some specific additional features(see above), in addition, programs on them can be run immediately after the change, which facilitates development. An interpreted language program can often be run in different types machines and operating systems without additional effort.
However, interpreted programs run noticeably slower than compiled programs, and they cannot run without an interpreter program.
This approach, in a sense, allows you to use the advantages of both interpreters and compilers. It should be mentioned that there are languages that have both an interpreter and a compiler (Forth).
Low level programming languages
The first computers had to be programmed with binary machine codes. However, programming in this way is a rather time-consuming and heavy task. To simplify this task, low-level programming languages began to appear, which made it possible to set machine instructions in a human-understandable form. To convert them into binary code, special translator programs were created.
An example of a low level language is assembly language. Low-level languages are focused on a specific type of processor and take into account its features, therefore, in order to port an assembler program to another hardware platform, it must be almost completely rewritten. There are also certain differences in the syntax of programs for different compilers. True, the central processing units for computers from AMD and Intel are practically compatible and differ only in some specific commands. But specialized processors for other devices, such as video cards and phones, contain significant differences.
Low-level languages are usually used to write small system programs, device drivers, interface modules with non-standard equipment, programming of specialized microprocessors, when the most important requirements are compactness, speed and the ability to directly access hardware resources.
High level programming languages
Specific Features computer architectures they are not taken into account, so the created applications are easily transferred from computer to computer. In most cases, it is sufficient to simply recompile the program for a specific computer architecture and operating system. It is much easier to develop programs in such languages and there are fewer errors. The program development time is significantly reduced, which is especially important when working on large software projects.
Now in the development environment, it is believed that programming languages that have direct access to memory and registers or have assembler inserts should be considered programming languages with a low level of abstraction. Therefore, most of the languages that were considered high-level languages before 2000 are no longer considered high-level languages.
The disadvantage of some high-level languages is the large size of programs compared to programs in low-level languages. On the other hand, for algorithmically and structurally complex programs, when using supercompilation, the advantage may be on the side of high-level languages. The text of programs in a high-level language is smaller, however, if taken in bytes, then the code originally written in assembler will be more compact. Therefore, high-level languages are mainly used to develop software for computers and devices that have large volume memory. And different subtypes of assembler are used for programming other devices, where the size of the program is critical.
Symbols used
Modern programming languages are designed to use ASCII, that is, the availability of all graphic ASCII characters is a necessary and sufficient condition for writing any language constructs. Managers ASCII characters are used to a limited extent: only carriage return CR, line feed LF, and horizontal tab HT (sometimes also vertical tab VT and next page FF) are allowed.
Early languages, which emerged during the 6-bit character era, used a more limited set. For example, the Fortran alphabet has 49 characters (including space): A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 = + - * / () . , $" :
A notable exception is the APL language, which uses a lot of special characters.
The use of non-ASCII characters (such as KOI8-R characters or Unicode characters) is implementation dependent: sometimes they are only allowed in comments and character/string constants, and sometimes they are also allowed in identifiers. In the USSR, there were languages where all keywords were written in Russian letters, but such languages \u200b\u200bdid not gain much popularity (the exception is the Built-in programming language 1C: Enterprise).
The expansion of the character set used is constrained by the fact that many software development projects are international. It would be very difficult to work with code where the names of some variables are written in Russian letters, others in Arabic, and still others in Chinese characters. At the same time, new generation programming languages (Delphi 2006, Java) support Unicode to work with text data.
Categories of programming languages
Mathematically based programming languages
These are languages whose semantics is immediate the embodiment of some mathematical model, slightly adapted (without violating integrity) in order to be a more practical language for developing real programs. Only a few languages fall into this category, most languages are designed with priority in terms of being able to translate efficiently to a Turing machine, and have only some subset in its composition, embodying one or another mathematical model - from
The personal computer, until the mid-sixties, was an overly expensive machine that was used exclusively for special tasks and that performed only one task at a time.
Programming languages at that time, as well as the computer device on which they were used, were developed only to perform tasks of a specific plan, for example, for scientific computing, and not. For the reason that machines, as we said above, were a very expensive pleasure, and only one task was performed at a time, time was considered expensive - therefore, the speed of program execution was in the foreground.
However, the cost began to decline during the sixties, and the time came when even small firms could afford this pleasure. In addition, the speed increased, and the machines were idle for a long time without performing any tasks. And to stop this, time-sharing systems were introduced.
The processor time in these systems, as it were, was "cut", and users could receive alternately short segments of this very time. The computer device began to work much faster, which allowed the user to feel at the terminal as if he was working with the system alone. The device, in turn, was idle less, as it carried out the execution of not one, but several tasks at once. Time sharing, to a large extent, reduced the cost of hardware time, and all thanks to the fact that one device could be shared not by one user, or even by two, but by hundreds.
So, when power became cheaper and more accessible, those who created programming languages began to think more and more about the convenience of writing software, and not about the speed of their execution. "Small" operations, that is, operations of the atomic type, which were directly performed by the devices of the devices, were combined into more "voluminous" high-level operations and single structures, with which it was much more convenient and easier for users to carry out their activities.
What are programming languages?
We will now give a clear answer to this question. A programming language is a formal sign system that is intended to describe algorithms in a more convenient form for the performer, for example, personal computer. A programming language includes a package of semantic, syntactic, and lexical rules that are used to create a computer program. With the help of such a language, the programmer will be able to accurately determine what events the PC will respond to, how information will be stored and transmitted, and also what actions need to be performed on these circumstances of various types.
Almost three thousand programming languages were invented during the creation of the first programmable devices. Their number increases every year, and the list is replenished with new ones. There are some languages that only a small number of creators who developed them can use, others become known to a large number of users. Specialists-programmers use more than ten different programming languages in their work.
What are programming languages for?
The process of running a PC is the execution of a program. To put it more plain language, that is, a batch of commands that follow in a certain order. The type of machine type instruction, which consists of zeros and ones, indicates what actions the central processor should perform. From this it follows: in order to set the PC the sequence of actions to be performed, a sequence of binary type codes of the corresponding commands is set. In machine code, software consists of many instructions. Writing such software is laborious, heavy and tedious. The programmer must know the combination of ones and zeros of the binary type code of each program, in addition, he must remember the binary type codes of the data addresses that are used in its execution. It is much easier to write software in a language that is closer to human natural language and have a PC translate that program into machine type codes. This is how programming languages appeared, which are intended specifically for writing software.
Now there are a large number of different programming languages. To solve many problems, you can apply each of them. Specialists in their field know exactly which programming language to use to solve any problems, since each of the languages \u200b\u200bis equipped with its own capabilities, orientation to certain types of tasks, and also have their own way of describing objects and concepts that are used to solve a large number of problems.
Programming languages are divided into 2 groups
There are languages that have low level and languages that have a high level.
The first group includes assembly languages, where instruction symbols are used in the form of symbols that are quickly and clearly remembered. Symbolic designations are written instead of a sequence of commands of a binary type, and instead of the addresses of the binary type data that are used when executing the command, the names chosen by the programmers and the names of these data in the form of characters are taken. Such a programming language has another name - autocode or mnemonic code.
But, programming languages that have a high level are most often used for programs by those who create them. Such a language, in principle, just like the human language, has its own alphabet, namely, a large number of symbols that are used in languages. These characters are necessary to form the keywords of the language. Each keyword has its own function, just like in the language we are used to, words that are made up of alphabetic letters. Keywords with each other are combined into sentences using the syntactic rules of the language. Each of all sentences is responsible for the sequence of actions that the PC will perform.
A programming language that has a high level is the link between the PC and the user, offering him to communicate with the PC in a way that is most convenient for the person. Quite often, this language helps to choose the right method of solving problems.
Before starting to write software in a programming language that has a high level, a specialist draws up an algorithm for resolving problems, namely, he draws up a step-by-step action plan that must be performed to solve this problem. Therefore, programming languages that require the preliminary compilation of an algorithm are called algorithmic type languages.
Well, here we come, we can say to the main thing. Now we will tell you what programming languages are.
What are the programming languages
Fortran
Back in the mid-fifties, scientists began to create programming languages. And the very first language of this type was called Fortran, and it was developed in 1957. It is used to describe an algorithm for solving problems of a scientific and technical type using a digital computer. In addition, like the first computing units, this type of language was used to carry out natural science and mathematical calculations. This language in an improved type has survived to our time, and it is, among modern languages that have a high level, the most used in scientific research. The most common variants today are: Fortran-I2, Fortran-I4, EASIC Fortran and their generalizations.
ALGOL
We continue our theme of programming languages. As you already understood, now we will talk about such a programming language as Algol, which appeared in 1958-1960. In 1964-1968 it was improved, so Algol - 68 appeared. This type of language was developed by a committee, which included scientists from America and Europe, and attributed it to languages that have a high level. Using a language of this type, algebraic formulas could be easily translated into program commands. Algol was popular not only in Europe, but also in Russia. For all programming languages created after some time, this type of language had a noticeable impact, and in particular, this affected the Pascal language. This type language, in principle, just like the Fortran language, was created to solve problems of a scientific and technical type. In addition, the language was used as a means of teaching the basics of programming, that is, the art of compiling software.
cobol
The Cobol programming language was created in 1959-1960, and this language belongs to the third generation. First of all, it is intended for the development of applications for business and for solving problems of an economic type, for processing banking data, for insurance companies and other institutions. Cobol's "inventor" is Grace Hopper. Usually, for cumbersomeness and verbosity, COBOL is criticized, since one of the goals of the creators of this language was the maximum approximation to English language. At the same time, the programming language had for its time excellent means for carrying out activities with data structures and files, and this, by the way, provided it with a long life in business applications. At least in the US, that's for sure.
Lisp
Next in line is the Lisp programming language. The Lisp programming language was developed almost at the same time as the Cobol programming language. This language is based on the program representation of system linear lists of symbols, which are the main data structure of the language. It is the second oldest programming language after Fortran. It is used extensively to process information in the form of symbols and is used to create software that mimics the activity of the human brain.
A program created in Lisp consists of sequences of expressions, that is, forms. The result of the program is the calculation of these expressions, which are written in the form of a list - one of the main structures of this type of language. The main meaning of the Lisp program is "life" in character space.
BASIC
The BASIC programming language was developed by programmers at Dartmouth College in the USA in the mid-sixties. The language was based partly on Fortran 2 and partly on Algol - 60, additions were also made that made it more convenient for working in time-sharing mode, and after a few years it became more convenient for text processing and matrix arithmetic. This kind of programming language was originally implemented on the GE-265 mainframe, which supports a large number of terminals. At the time of its inception, contrary to popular belief, it was a compiled language.
This kind of programming language was designed so that students could write programs using time-sharing terminals. It was created not only to solve a problem that is associated with problematic, older languages, but also it was intended to be used by "simple" users who are not interested in the speed of the program, but are interested in the possibility of using a PC to resolve their tasks. Most novice programmers, due to the simplicity of this type of language, start their programming journey with it.
Fort
The Forth programming language appeared in the late sixties and early seventies. This type of language was used in the tasks of controlling various kinds of systems after its creator, Moore Charles, wrote software on it that was intended to control the radio telescopes of the Arizona observatory.
Many properties, such as flexibility, interactivity, and ease of "invention," have made Forth an effective and attractive language in applied research and in the creation of tool-type tools. The obvious applications of this kind of programming language are embedded control systems. In addition to all of the above, he also found application in programming PCs running various kinds of operating systems.
Pascal
Continuing the topic, one cannot fail to note such a type of programming language as Pascal. Pascal was created in 1972 and named after Blaise Pascal, who was once a great mathematician and inventor of the world's first arithmetic unit. By right, the creator of the language is the Swiss scientist, computer scientist Nikolaus Wirth. The innovation was used for teaching programming methods. Pascal is a general purpose programming language.
Of all its features, the main ones can be called - this is the strictest typing and the availability of programming tools of a structural type. Pascal was one of the first such languages. The Pascal programming language teaches how to write a program correctly and how to develop methods for solving problems, and it also helps to learn how to choose the right options for representing and organizing data that are used in a problem. Since 1983, the Pascal language has been introduced into the computer science courses of secondary educational schools USA.
Continuing the topic of programming languages, we decided to talk about another type of language - the Ada language. The Ada programming language was created from Pascal in the late seventies and named after Ada Lovelace, a gifted female mathematician. It was this talented woman who in 1843 explained to the whole world the possibilities of Charles Babbage's Analytical Unit. This type of language was developed by order of the US Department of Defense, and was originally used to solve space flight control problems.
The Ada programming language is a modular, structured, and object-oriented programming language that contains high-level parallel process programming tools. The syntax of this type of programming language is taken from Pascal and Algol, it has been expanded and implemented in a logical and strict style. Ada is a programming language that has strong typing, and it completely excludes work with objects that do not have types, and also reduces automatic conversions to an absolute minimum.
The C programming language is by far the most popular and used among programmers. This type of programming language originates from 2 languages, namely, BCPL and B. Martin Richards created BCPL in 1967 as a language that was intended for writing system software and compilers. What it is, we will describe below. Ken Thompson in 1970 to create more early versions UNIX OS used on PC DEC PDP-7. In both the first and second languages, variables were not divided into types - each data value had one word in memory.
The C programming language was first implemented in 1972 on the DEC PDP-11 PC. But he managed to get his popularity and fame as operating system UNIX. All major operating systems today are written in C or C++. The C programming language, after several decades, is available on a large number of PCs. And by the way, it is worth noting that it is completely independent of the hardware.
In the traditional programming language - the C language has become in the late seventies. This type of language is equipped with rich tools that provide the ability to write flexible software that is used in all kinds of modern PCs.
Prologue
Well, we've come to the end. We will end our topic on programming languages with a story about the latest language in this area - and it is called Prolog. This type of language is considered the programming language of the future, and it was created in the early seventies. Experts from the University of Marseille took part in the development. They named it from the words "PROGRAMMING IN THE LOGIC LANGUAGE". The programming language was created on the basis of the laws of mathematical logic. This type of language, unlike the programming languages that were described above, is not algorithmic and it belongs to the so-called descriptive, that is, descriptive languages.
Now let's talk about what a compiler and an interpreter are?
Compiler and interpreter
It is not enough to develop a language that would be convenient for writing a program. Each language must have an interpreter, who is special program- translator.
So, a translator is a program that is designed to translate software that was written in one programming language into software in another programming language. This translation process is called translation. An example of a translator is a compiler, which is also a program. It is intended for translating software written in any language into software in machine type codes. This process is called compilation.
There is another way that can combine the processes of translation and program execution, and it is called interpretation. The essence of the process is as follows: first it is translated into machine type codes, then the first line of the software is executed. When the execution of the first line is completed, the translation of the second line begins, and so on.
So, from this we can conclude that an interpretation is a program that is intended for line-by-line translations and the original program.
Well, it seems that's all for today, now you know what are programming languages and what they are.
