Formalized programming languages. High level programming languages. Types of programming Programming languages are formal languages specially created for communication between a person and a computer. Applied computer software
Over the past 70 years, programming has become a vast area of human activity, the results of which, in their practical significance, are quite comparable with the latest results in the field of nuclear physics or space research. These results are largely related to the emergence and rapid development of high-level algorithmic languages.
Modern high-level programming languages such as Pascal, C, Ada, Java, C++, C# and others are still the most common and powerful tool for programmers involved in the development of both system and application software. With the advent of new tasks and needs, the functionality of these languages is constantly expanded by creating more and more advanced versions.
Another direction in the development of programming languages is associated with the creation of specialized (problem-oriented) software systems and environments for non-programmer users (technologists, designers, economists, etc.). Examples of such systems and environments are CAD for various purposes, automated learning systems, distance learning systems, expert and modeling systems in the economy, etc. The purpose of the corresponding problem-oriented languages used in such systems is often reflected in their names, for example: "Language for describing the schemes of technological equipment", "Language for describing the training scenario", "Situation modeling language", etc.
Both general-purpose and domain-specific programming languages have one thing in common - they are
formal languages. What is a formal language? In the most general form, this question can be answered as follows: language - it's a lot of suggestions formal language - it is a language whose sentences are built according to certain rules.
Sentences are built from words, and words are built from symbols (letters). The set of all admissible symbols is called alphabetically language. In programming languages, sentences usually correspond to operators (or instructions), and we see alphabetic characters on a computer keyboard.
Both natural languages and programming languages are infinite sets. An unlimited number of programs can be written in a programming language.
How to set the rules for constructing sentences in a formal language? In answering this question, we will start from two important concepts: syntax and semantics language.
Syntax language determines the structure of correct sentences and words, and in programming languages, among other things, the permissible structures of program texts.
There are various ways to describe the syntax of formal languages (the second chapter of the tutorial is devoted to ways of describing it). The most used in programming languages are backus form - Naura(BNF) and syntax diagrams.
The BNF was developed by Backus and was first used for a strict description of the ALGOL-60 language in 1963. This form is used both to describe the structure of the language as a whole and to describe individual language constructs (subsets of the language) and its elements - operators, identifiers, expressions, numbers, etc.
The following are BNF examples that define the syntax for decimal integers and the syntax for arithmetic expressions containing the "+" and "*" operators.
BNF decimal integers:
= 0|1|...|9
BNF of arithmetic expressions:
:= () a
In the above expressions a stands for any identifier and is treated as a character of the alphabet from which the expression is built.
On the left side of the BNF, the names of the defined parameters are written in angle brackets. syntactic categories(concepts, units), the symbol “:=” means “is”, “this”, “is defined as”, the symbol “|” means "or".
The right part of the BNF defines possible options for constructing specific values of these categories, in this case, the values of decimal numbers and specific arithmetic expressions. The BNF also contains the alphabet of characters from which these values are composed. For decimal integers, the alphabet is the set (+,-, 0, 1,..., 9), and for expressions it is the set (a, *, +, (,)}.
The process of constructing the meanings of a syntactic category consists in withdrawal these values by successive substitutions of the right parts of the BNF rules into the left ones. The following are the derivations of the number "-320" and the expression "a+a*a" using the corresponding BNF:
BNF are very similar to formal grammars used in the theory of formal languages (some authors identify them).
It was the appearance of the BNF that stimulated the rapid development of the theory of formal languages and its application to applied problems of developing programming languages and designing translators.
If in the considered BNF each syntactic category from the left side of the rules is denoted by A, B and FROM respectively, and instead of the symbol:= use -then the following forms will be obtained:
For decimal integers:
A->B+B-B B^>CBC C->0 | 11... | 9
For arithmetic expressions:
A^A+BB
B->B*SS
C^>(A)a
This is how the rules are written formal grammars. Symbols denoting syntactic categories, in this case, B, C in formal grammars are called non-terminal symbols and the characters of the alphabet are terminal.
In practice, after obtaining the grammar of a programming language in the "first approximation", it is necessary to investigate its properties, and in some cases, perform some transformations. This is mainly due to the need to bring the grammar to a form convenient for constructing the corresponding translator. In the process of performing these transformations, from a formal point of view, it does not matter what specific syntactic categories and symbols of the alphabet BNF contains. Therefore, at this stage, one usually moves on to formal grammar and uses the appropriate methods of the theory of formal languages. At the same time, BNF should not be completely identified with formal grammars. The definition of grammar in the theory of formal languages is more general. In particular, they can be used to describe context dependencies, which cannot always be avoided in the development of programming languages and which cannot be described using BNF.
A characteristic feature of the grammars of programming languages is the presence of recursion in them. recursiveness means that the definition of some syntactic category contains the defined category itself (this is the so-called explicit recursion). For example, in the considered BNF, the definitions for the categories and contain these categories themselves on the right side. Recursion - an almost inevitable property of the grammars of programming languages, which makes it possible to make them infinite. At the same time, some types of recursion, which will be discussed later, significantly complicate the process of developing the corresponding translators.
Let us dwell briefly on another way of describing the syntax of a language, mentioned above, with the help of syntax diagrams. Some authors, when describing the language standard, prefer this method due to its greater clarity. Examples of syntax diagrams can be found in many programming books (for example, in ). Note that both description methods - both BNF and syntactic diagrams are equivalent and you can always switch from one description method to another.
Consider now the concept the semantics of the language. If the syntax of a language determines the structure of its correct sentences and texts, then the semantics determines the correctness of their meaning. In turn, the correctness of the meaning depends on the meanings of the words that make up the sentence. For example, if in natural language the sentence syntax is defined as
then you can build a set of sentences with different meanings. For example, the sentences "car drives" and "car thinks" are correct in terms of syntax. However, the first sentence has the correct meaning; the second can be said to be meaningless. Thus, semantics determines the set of meanings and admissible correspondences between sentences (texts) and meanings.
In addition, the semantics of a language depends on the properties of objects described in this language. If in the considered example the car would be equipped with a computer with programs for calculating the optimal modes and routes of movement, then the second sentence would no longer seem meaningless.
Similarly, in programming languages, the syntactically well-formed assignment operator
will be semantically incorrect if a is 10.5 (a = 10.5) and b is false (b = false).
The formal description of the semantics of programming languages turned out to be a much more difficult task than the description of syntax. Most of the works devoted to the application of mathematical methods in the implementation of programming languages cover exactly the issues of describing the syntax and constructing parsing methods. A fairly holistic theory and methodology has developed in this area. At the same time, the semantics of language and semantic analysis are still the subjects of many studies.
Many aspects of the semantics of a programming language can be described as a list of semantic conventions that are of a general, informal nature. For example, programmers are familiar with such conventions as "each identifier in a block is declared once", "a variable must be defined before it can be used", etc.
As an example of the successful application of the theory of formal languages in the field of semantics and semantic analysis, one can cite the apparatus of attribute translational grammars, which allows one to take into account semantic agreements in the description of a language and control their observance during program translation.
As for the forecasts for the prospects for the further development of programming languages, there is a fairly wide range of opinions, up to diametrically opposed ones. Some authors believe that each of the languages has its own semantic features that make it convenient and attractive for a particular area of programming (for example, Prolog and Lisp are focused on solving artificial intelligence problems; Fortran is the most effective in solving computational problems; Cobol - used for economic calculations, etc.). Therefore, you should create all new languages that have specific features or periodically update existing versions, and not try to create a universal language. In support of this point of view, the argument is made that all ambitious projects to create a universal language have failed (suffice it to recall the unfulfilled hopes associated with the development of ADAiPL-1 languages).
Another part of the authors believes that since the publication of the standards of the first programming languages - Fortran, Algol, etc. - in the 60s. In the 20th century, there was a “stabilization” of languages in the sense that language constructions similar in purpose in different languages have practically the same semantic basis, despite differences in vocabulary and syntax. Therefore, as soon as it is possible to formally define this common semantic base, it will be possible to start creating a universal language, which will no longer be a programming language in the traditional sense, but blanks of semantic structures. The program will be presented as a set of these constructs, and the text editor will give way to the structure editor. As an example of a partial implementation of this approach, visual programming environments such as Delphi, C ++ Builder, etc. are given.
End
Start
Repeat
Start
Pseudo codes
Pseudocode is a system of notation and rules designed to uniformly write algorithms. It occupies an intermediate position between natural and formal language.
On the one hand, it is close to ordinary natural language, so algorithms can be written and read in it like plain text. On the other hand, some formal constructions and mathematical symbolism are used in pseudocode, which brings the notation of the algorithm closer to the generally accepted mathematical notation.
Pseudocode does not adopt strict syntactic rules for writing commands inherent in formal languages, which makes it easier to write an algorithm at the design stage and makes it possible to use a wider set of commands designed for an abstract executor. However, in pseudocode, there are usually some constructs that are inherent in formal languages, which facilitates the transition from writing in pseudocode to writing an algorithm in a formal language. In particular, in pseudocode, as well as in formal languages, there are auxiliary words, the meaning of which is determined once and for all. They are bolded in printed text and underlined in handwritten text. There is no single or formal definition of pseudocode, so various pseudocodes are possible, differing in the set of service words and basic (basic) structures. As an example, we give an entry on one of the pseudocodes of the algorithm:
algorithm Euclid's algorithm;
bye the first number is not equal to the second
if the numbers are equal
then stop all;
otherwise determine the larger of two numbers;
h Change the larger number to the difference between the larger and smaller numbers
the end;
take the first number as the answer
This algorithm can be written in a simpler way, but just such a notation is given to demonstrate the main possible pseudocode constructions. By virtue of their peculiarities, pseudocodes, like the other means of writing algorithms described above, are human-oriented.
It was noted above that when writing an algorithm in verbal form, in the form of a diagram, or in pseudocode, a certain arbitrariness is allowed when displaying commands. At the same time, such a record is so accurate that it allows a person to understand the essence of the matter and execute the algorithm.
However, in practice, special automata - electronic computers (computers) - are used as executors of algorithms. Therefore, an algorithm intended for execution on a computer must be written in a language "understandable" by the computer. And here the need for an accurate recording of commands, leaving no room for arbitrary interpretation by their performer, comes to the fore. Therefore, the language for writing the algorithm must be formalized. Such a language is called programming language , and the record of the algorithm in this language is program for computer.
Programming language is a formalized language, which is a combination of the alphabet, the rules for writing constructions (syntax) and the rules for interpreting constructions (semantics).
At present, there are several hundred programming languages designed for different areas of application of computers, that is, for different classes of tasks solved with the help of computers. These languages are classified according to different levels, taking into account the degree of dependence of the language on a particular computer.
Programming is a whole science that allows you to create computer programs. It includes a huge number of different operations and algorithms that form a single programming language. So, what is it and what are the programming languages? The article provides answers, as well as an overview list of programming languages.
The history of the emergence and change of programming languages should be studied along with the history of the development of computer technology, because these concepts are directly related. Without programming languages, it would be impossible to create any program for the operation of a computer, which means that the creation of computers would become a meaningless exercise.
The first machine language was invented in 1941 by Konrad Zuse, who is the inventor of the Analytical Engine. A little later, in 1943, Howard Aiken created the Mark-1 machine, capable of reading instructions at the level of machine code.
In the 1950s, there was an active demand for software development, and machine language could not withstand large amounts of code, so a new way of communicating with computers was created. "Assembler" is the first mnemonic language to replace machine instructions. Over the years, the list of programming languages is only increasing, because the scope of computer technology is becoming more extensive.
Classification of programming languages
At the moment there are more than 300 programming languages. Each of them has its own characteristics and is suitable for one specific task. All programming languages can be divided into several groups:
- Aspect-oriented (the main idea is the separation of functionality to increase the efficiency of program modules).
- Structural (based on the idea of creating a hierarchical structure of individual blocks of the program).
- Logical (based on the theory of the apparatus of mathematical logic and resolution rules).
- Object-oriented (in such programming, algorithms are no longer used, but objects that belong to a certain class).
- Multi-paradigm (combine several paradigms, and the programmer himself decides which language to use in this or that case).
- Functional (the main elements are functions that change value depending on the results of the calculations of the initial data).
Programming for beginners
Many people ask what is programming? Basically, it is a way to communicate with a computer. Thanks to programming languages, we can set specific tasks for various devices by creating special applications or programs. When studying this science at the initial stage, the most important thing is to choose suitable (interesting for you) programming languages. The list for beginners is below:
- Basic was invented in 1964, belongs to the family of high-level languages and is used to write application programs.
- Python ("Python") is quite easy to learn due to its simple, readable syntax, but the advantage is that it can be used to create both ordinary desktop programs and web applications.
- Pascal ("Pascal") - one of the oldest languages (1969) created for teaching students. Its modern modification has strict typing and structure, but "Pascal" is a completely logical language that is understandable on an intuitive level.
This is not a complete list of programming languages for beginners. There are a huge number of syntaxes that are easy to understand and will definitely be in demand in the coming years. Everyone has the right to independently choose the direction that will be interesting for him.
Beginners have the opportunity to accelerate the learning of programming and its basics thanks to special tools. The main assistant is the Visual Basic integrated development environment for programs and applications ("Visual Basic" is also a programming language that inherited the style of the Basic language of the 1970s).
Programming language levels
All formalized languages designed to create, describe programs and algorithms for solving problems on computers are divided into two main categories: low-level programming languages (the list is given below) and high-level ones. Let's talk about each of them separately.
Low-level languages are designed to create machine instructions for processors. Their main advantage is that they use mnemonic notation, that is, instead of a sequence of zeros and ones (from the binary number system), the computer remembers a meaningful abbreviated word from the English language. The most famous low-level languages are "Assembler" (there are several subspecies of this language, each of which has much in common, but differs only in a set of additional directives and macros), CIL (available in the .Net platform) and JAVA Bytecode.
High-level programming languages: list
High-level languages are designed for convenience and efficiency of applications, they are the exact opposite of low-level languages. Their distinguishing feature is the presence of semantic constructions that concisely and briefly describe the structures and algorithms of the programs. In low-level languages, their description in machine code would be too long and incomprehensible. High-level languages, on the other hand, are platform independent. Instead, compilers perform the translator function: they translate the program text into elementary machine instructions.
The following list of programming languages: C ("C"), C # ("C-sharp"), "Fortran", "Pascal", Java ("Java") - is among the most used high-level syntaxes. It has the following properties: these languages work with complex structures, support string data types and file I/O operations, and also have the advantage of being much easier to work with due to readability and understandable syntax.
Most used programming languages
In principle, you can write a program in any language. The question is, will it work efficiently and without fail? That is why the most suitable programming languages should be chosen for solving various problems. The popularity list can be summarized as follows:
- OOP languages: Java, C++, Python, PHP, VisualBasic and JavaScript;
- group of structural languages: Basic, Fortran and Pascal;
- multi-paradigm: C#, Delphi, Curry and Scala.
Scope of programs and applications
The choice of the language in which this or that program is written depends largely on the area of its application. So, for example, to work with the computer hardware itself (writing drivers and supporting programs), the best option would be C ("C") or C ++, which are included in the main programming languages (see the list above). And for the development of mobile applications, including games, you should choose Java or C # ("C-sharp").
If you have not yet decided which direction to work in, we recommend that you start learning with C or C ++. They have a very clear syntax, a clear structural division into classes and functions. In addition, knowing C or C ++, you can easily learn any other programming language.
About railway language "The train will pass the Krasnye Zori platform without stopping." Note that the driver used the noun "stop" and not the verb "stop". Stopping is a very important concept for railway workers. A train may "stop", but not "have stops". Turchin [Turchin 2000], giving a similar example, points to the formalization of the language used for narrow professional purposes.
A formalized language can be defined as follows [Turchin 2000]. Consider a two-story language model of reality (Fig. 4. 4). The situation si is encoded by the language object Li. The object L1 is the name for si. Some time later, situation S1 is replaced by situation S2. Carrying out some language activity, we transform L1 into another object - L2. If our model is correct, then L2 is the name of S2. As a result, without knowing the real situation S2, we can get an idea about it by decoding the language object L2. Performing the L1->L2 transformation determines whether the language will be formalized.
For a formalized language, the transformation L1->L2 is determined exclusively by the language objects Li that participate in it and do not depend on the language representations si corresponding to them in the semantics of the language.
For a non-formalized language, the result of the transformation of the language object Li depends not only on the type of the representation Li itself, but also on the representation si that it generates in the human head, on the associations it enters into.
A person is able to perceive the most unformalized languages. And the computer does not understand, more precisely, cannot execute the program in an informal language. That is why an important place in the study of programming is always occupied by formal algorithmic programming languages,
On the formalization of the informal Formalization of the unformalized is an unformalizable process. Although the logicians and the military are trying to fight this.
About the formula of love The formula of love does not lend itself to formalization. At best, it can only be represented as a very rough model.
Modeling languages
Modeling language - a set of rules that determine the construction of models (a simplified representation of reality), including their visualization and the definition of structure and behavior. The modeling language includes:
model elements - fundamental concepts of modeling and their semantics;
notation - visual representation of modeling elements;
usage guide - rules for the use of elements in the framework of building domain models.
Programming languages and integrated environments
According to the creator of the first FRAMEWORK integrated environment, an integrated environment is such an application that the user, having launched it at the beginning of the working day, finds all the resources necessary for work in it and therefore does not exit the integrated environment until the very end of the working day. Of course, this definition is not very correct and somewhat idealizes the situation, but its general meaning is clear enough. The main feature of integrated environments is a high degree of interactivity. It is achieved by integrating various software resources into a single whole, hence the name. So, the integrated environment of a programming language compiler (a program that creates an executable program from the text of this programming language) usually contains a text editor and the compiler itself with a compilation error diagnostic system. In addition, it usually also has a debugger - an interpreter of this language, which executes the program line by line and has a number of other special features. One of the actively developing areas, visual design, is completely based on the use of the capabilities of an integrated environment. The user interactively selects the programming language objects necessary for his program and establishes links between them. The popularity of such languages as Visual BASIC (Microsoft), as well as Object PASCAL (Delphi and Kylix, Borland environments) is not accidental. Even an inexperienced programmer who does not know other programming languages besides BASIC and has never programmed under Windows can create an application program running under Windows using Visual BASIC in two or three days. But a high-class programmer who has not programmed under Windows before, using C ++, often has to spend weeks or even months to create the same program. True, Visual BASIC has a number of significant limitations. With the help of visual design environments, you can create very complex programs without typing a single line of code on the keyboard. However, all programs based on traditional procedural programming languages suffer from the same drawback. For them, the executable code is one thing, and the data processed by the program is quite another. Indeed, the program code is contained in a file with the EXE extension, and the data is either in special data files (usually in text or binary form in the internal representation of the computer), or is entered from the keyboard or from some other external device. And now let's ask the question: what if the user must give the executable program information that can be considered as an “addition” to the program text? For example, we want a function graph to be built on the screen, and in such a program we provide all the necessary service capabilities. However, the formula for the function must be set by the user himself, and it is not known in advance what it will be. It is quite obvious that such tasks can be solved only with the help of an interpreter system. But “you have to pay for everything”. The compiler translates the text of the program into executable code that can work without a compiler program. Programs created on the basis of interpreting type languages can only be executed under the control of an interpreter program. They are also slower than compiled ones because they take extra time to interpret. However, in many cases this is not significant.
Date of creation: 1963 Influenced: PROFT Typing: untyped Dialects:
Applesoft BASIC
Commodore BASIC
Microsoft BASIC
Implementations and versions:
Applesoft BASIC Interpreter in Javascript
Atari Microsoft BASIC I/II
Commodore BASIC
Galaxia BASIC
Microsoft Visual Basic
Visual Basic for Applications
BASIC (BASIC - short for Beginner's All-purpose Symbolic Instruction Code - a universal code for symbolic instructions for beginners; English basic - basic, basic) - a family of high-level programming languages.
BASIC was conceived in 1963 by Dartmouth College professors John Kemeny and Thomas Kurtz and implemented under their guidance by a team of college students. Over time, as other dialects began to appear, this "original" dialect became known as Dartmouth BASIC.
BASIC was designed so that students could write programs using time-sharing terminals. It was created as a solution to the problems associated with the complexity of older languages, intended for more "simple" users, not so much interested in the speed of programs, but simply in the ability to use a computer to solve their problems.
The following eight principles were used in the design of the language:
be easy to use for beginners;
be a general-purpose programming language;
provide the ability to extend the functionality available to experienced programmers;
be interactive;
provide clear error messages;
work quickly on small programs;
do not require understanding of the operation of the hardware;
be an intermediary between the user and the operating system.
The language was based partly on Fortran II and partly on Algol-60, with additions to make it suitable for time-sharing, text processing, and matrix arithmetic. BASIC was originally implemented on the GE-265 with support for multiple terminals. Contrary to popular belief, at the time of its inception it was a compiled language. The language gained general popularity from its appearance on the Altair 8800 microcomputer. Many programming languages were too cumbersome to fit in small memory. For machines with slow media like paper tape, audio cassette, and no suitable text editor, a small language like BASIC was a godsend. In 1975, Microsoft (then it was only two - Bill Gates and Paul Allen, with the participation of Monte Davidov) released Altair BASIC. For the CP / M operating system, the BASIC-80 dialect was created, which determined the development of the language for a long time. Several new versions of BASIC were created during this period. Microsoft sold several versions of BASIC for MS-DOS/PC-DOS, including BASICA, GWBASIC, and Quick BASIC (QBASIC). Borland released Turbo BASIC 1.0 in 1985 (its successors were subsequently sold by another company under the PowerBASIC name). Various BASIC extensions appeared on home computers, usually including tools for working with graphics, sound, executing DOS commands, as well as tools for structured programming. Some other languages used the well-known BASIC syntax as the basis on which a completely different system was built (see, for example, GRASS). However, starting in the late 80s, new computers became much more complex and provided features (such as a graphical user interface) that made BASIC no longer as convenient for programming. BASIC began to lose ground, despite the fact that a huge number of its versions were still used and sold. BASIC received a second life with the advent of Microsoft's Visual Basic. It has become one of the most used languages on the Microsoft Windows platform. Later, a variant called WordBasic was created, used in MS Word until Word 97. The Visual Basic for Applications (VBA) variant was built into Excel 5.0 in 1993, then into Access 95 in 1995, and then into all other tools. , included in the Office package - in 1997. Internet Explorer 3.0 and above, as well as Microsoft Outlook included a VBScript language interpreter. The full version of the OpenOffice.org package also includes a BASIC interpreter.
Hello, World!: Example for QBasic 1.1, QuickBasic 4.50
PRINT " hello , World !"
Factorial: Example for QBasic 1.1, QuickBasic 4.50
An iterative definition of the factorial is used. When calculating 13! an arithmetic overflow occurs, and here the behavior of different implementations differs: QBasic reports an overflow, while QuickBasic simply prints negative values. In addition, the PRINT command prints one space before and after a number by default.
DIM f AS LONG f = 1 PRINT "0 !="; f FOR i = 1 TO 16:
f = f*i:
PRINTi; "!="; f
FORMALIZED LANGUAGE- an artificial sign system designed to represent some theory. A formalized language differs from the natural (national) languages of human communication and thinking, from artificial languages such as Esperanto, from the "technical" languages of science, which combine the means of a certain part of the natural language with the corresponding scientific symbols (the language of chemistry, the language of ordinary mathematics, etc.), from algorithmic language generic programming type, etc. first of all, by the fact that its task is to serve as a means of fixing (formalizing) a certain logical content, which allows introducing the relation of logical consequence and the concept of provability (or their analogues). Historically, the first formalized language was syllogistic Aristotle, implemented using a standardized natural (Greek) language fragment. The general idea of a formalized language was formulated by Leibniz (characteristica universalis), who provided for its extension to the "calculus of inferences" - calculus ratiocinator. In modern times, various variants of formalized languages were developed on the basis of the analogy between logic and algebra. The milestone here was the work Morgana , Boole and their followers, especially Schroeder and Poretsky . Modern formalized languages—in their most common forms—go back to labor. Frege "Begriffsschrift" - "Recording in Concepts" (1879), from which comes the main line of development of the language of propositional logic and (embracing it) the logic of (multiple) predicates, as well as the application of these logical linguistic means to the problems of substantiating mathematics.
The characteristic structure of such formalized languages: the assignment of the alphabet of initial signs, the inductive definition of a (well-formed) formula of the language, the so-called. setting the rules of formation, setting the rules of inference, the so-called. transformation rules that preserve the selected logical characteristic of formulas (truth, provability, etc.). The addition of transformation rules turns the formalized language into a logical calculus. There are many types of formalized languages: these are, first of all, languages of deductive-axiomatic constructions, systems of natural ("natural") inference and sequential constructions, analytical tables, "argument logic" systems, and many others.
Formalized languages differ in their logical strength, from "classical" languages (in which the Aristotelian laws of identity, contradiction and excluded middle, as well as the principle of logical ambiguity, are in full force) and ending with numerous languages of non-classical logics that allow weakening certain principles, introduce polysemy of evaluations of formulas or their modalities. Languages have been developed in which logical means are minimized in one sense or another. Such are the languages of minimal and positive logics or the language of propositional logic, which uses a single logical operation, for example. Schaeffer's stroke (see Logical connectives ).
Formalized languages are usually characterized in terms of syntactic and semantic. But the most essential is that logical characteristic of his formulas, which is preserved by the rules of inference (truth, provability, verifiability, probability, etc.). For any formalized language, the fundamental problems are the completeness of the logic expressed in it, its decidability and consistency; e.g. the language of classical propositional logic complete, resolvable and consistent, and classical predicate logic (multiple) though complete, but unsolvable; the language of the extended predicate calculus - with quantifiers by predicates and unlimited application of the principle of abstraction - is contradictory (such was Frege's logical-arithmetic system, in which Russell discovered the antinomy named after him).
A formalized language can be a "pure form", i.e. not carry any extralogical information; if it carries it, then it becomes an applied formalized language, the specificity of which is the presence of constant predicates and terms (descriptions) - for example. arithmetic - reflecting the properties of the application area. To formalize theories of a high level of abstraction, a formalized language can be modified, extended, or "built on" in various ways; example: formalization of classical calculus as second-order arithmetic (i.e. with quantifiers over predicate variables). In a number of cases, a formalized language contains logical structures of many – even infinitely many – orders (such, for example, as A.A. Markov’s “tower of languages”, which serves to formalize constructive mathematics, or the interpretation of modalities in the form of a hierarchy of “possible worlds”). The semantic base of a formalized language of logic can be set-theoretic, algebraic, probabilistic, game-theoretic, etc. There may also be such “weakenings” of it that are only akin to probabilistic semantics - this is how, for example, a formalized language of “vague logic” arises (in the sense Zade). Then the language acquires a specific pragmatics, taking into account the factor of the native speaker (giving an assessment of the “belonging function” of the subject to the scope of this concept). This is where the now growing tendency to take into account the “human factor” in formalized languages, in one form or another, is manifested, which is clearly manifested in some formalized languages of the logic of quantum mechanics. In another direction, there is the development of formalized languages, the semantics of which implies the rejection of existential assumptions or certain ontological premises - the admissibility of rules with an infinite number of premises, the "multi-sort" of subject areas, even contradictory ones, etc.
An indispensable feature of a formalized language is the "possibility" interpretation of the rules of inference; for example, at a certain step we are free to use or not to use, say, the modus ponens rule. This feature is deprived of algorithmic languages, which have a "prescriptive" character. But with the development of computer logic and the development of programs of the "describing" type, this difference begins to smooth out. The development of formalized languages focused on solving heuristic problems also operates in the same direction.
Literature:
1. Church A. Introduction to mathematical logic, vol. 1. M., 1960;
2. Kleene S.K. Introduction to metamathematics. M., 1957;
3. Curry H. Foundations of mathematical logic. M., 1969;
4. Freudenthal H. The language of logic. M., 1969;
5. Smirnova E.D. Formalized languages and problems of logical semantics. M., 1982.