The first programming language was created. How do you still choose your (first) programming language? Or How to ask the right questions? What is a programming language

If you are thinking of learning programming, the programming language you decide to choose first is of great importance, it should be related to what you want to do in the future and be relevant. While programming in general is not for the lazy, some languages ​​are easier to learn than others and have communities that are dedicated to learning and offer useful skills for learning other programming languages.

Selection scheme

There are questions that are asked so often that entire diagrams are created to answer them. Here, for example, is one of them, dedicated to choosing the first programming language.

When choosing your first programming language, you should soberly evaluate the following factors:

  • Labor market.
  • Long-term prospects for language.
  • Difficulty learning a language.
  • What exactly can you create in the process of studying, and, showing others, maintain motivation.

Popularity and demand

JavaScript

JavaScript, not to be confused with Java, is a programming language that was developed in the 90s by Brendan Eich, formerly of Netscape Communications and now of the Mozilla Foundation. JavaScript is one of the fundamental technologies that powers the web community as we know it. Don't be fooled, although JavaScript exists outside of the browser, it exists primarily in the context of connected applications and services.

The language itself is dynamic and gives programmers the flexibility to use object-oriented programming styles (since the language itself is primarily object-oriented), as well as functional and imperative. It derives most of its syntax from C, and if you plan to do any web development in any way, learning JavaScript should be on your list.

Luckily, JavaScript is relatively easy to learn, already in your browser for you to play with, and although it's been around for a while, it's quickly gaining popularity. Many of you who have nominated it have noted that your bang for the buck when learning JavaScript is huge because you can immediately use it to build things for the web, which may very well be what a lot of people learn to code.

Python

I can also recommend Python.

Despite a number of problems historically inherent to Python, it continues to be a leading tool in a number of niches:

Impressive, isn't it? As for large and popular projects written in Python, these are such monsters as:

You can also find on our website.

Programming is a labor-intensive and complex process that not everyone can comprehend. Machine language consists of many algorithms and And today's computers are such advanced equipment because they are programmed. And the history of software development would not have been so successful if a special language had not been invented for machines that translated symbolic keywords into machine codes. Let's look at how the history of the development of programming languages ​​took shape.

The first autocodes appeared in 1955 through the efforts of IBM developers under the leadership of engineer John Backus. It was a high-level language called Fortran, not a set of isolated simple commands, but an organization of larger codes that came to be called operators, or algorithmic languages. To translate them into machine code, translators were invented that transform the algorithms and make it understandable for an electronic computer. This happens in two ways: interpretation and compilation. Due to their simplicity, Fortran versions quickly came into use, and the last of them is still one of the main computers today.

However, this is not the only autocode for cars. The history of the development of programming languages ​​continues with the creation of Algol algorithms, which are used mainly in the scientific community and contain a large number of new concepts. This event takes place in 1960. And a little later, inquisitive employees of IBM came up with the Cobol language, oriented towards use in a business environment and used for processing complex and voluminous information of an economic nature.

The history of the development of programming languages ​​continues with Dartsmouth College professors T. Kurtz and J. Kemeny, who developed the well-known BASIC. It is much simpler than Fortran, and therefore was used in It had an explosive effect, becoming the main set of auto-programming codes, and making computers the property of the most ordinary users.

Ease of use and the possibility of interactive communication are the most important advantages of the BASIC language. The disadvantages include the lack of restrictions on the compilation of programs, which very often confuses them and makes them logically incomprehensible. Programs written using BASIC are slow because they are based not on compilers, but on interpreters.

Today, scientists continue to work on improving it and are trying to bring it closer to the Pascal program, which further marked the history of the development of programming languages. Professor of the Zurich Polytechnic University Niklaus Wirth is rightfully considered its creator. And he gave the name to his invention in honor of Pascal, who was the first designer of the very first computer. This is one of the easiest and most accessible programming languages, allowing you to write clear and understandable programs.

The history of the development of programming would be incomplete without the Ada language, named after the first female programmer Ada Lovelace, the daughter of the well-known sweat. It is a more advanced and universal programming language based on Pascal.

The history of software development has in its arsenal many more programming languages ​​that are written for special areas of application. For example, Simul, Simkrit and GPSS are used in modeling. The FORT language is used to control the equipment. are written in SI language. Databases are created using the Kodasil language. Logo, Robik and A.P. are convenient for learning programming. Ershova.

The history of programming development has not yet been fully written and it is unlikely to happen in the near future.

One of the most revolutionary ideas that led to the creation of automatic digital computers was the idea expressed in the 20s of the 19th century by Charles Babidge about pre-recording the order of operation of the machine for the subsequent automatic implementation of calculations - a program. And, although the recording of programs on punched cards used by Babyge, invented to control such machines by the French inventor Joseph Marie Jacquard, technically has nothing in common with modern methods of storing programs in a PC, the principle here is essentially the same. From this moment the history of programming begins.
Ada Levellace, a contemporary of Babidge, is called the world's first programmer. She theoretically developed some techniques for controlling the sequence of calculations that are still used in programming today. She also described one of the most important constructions of almost any modern programming language - a loop.

A revolutionary moment in the history of programming languages ​​was the emergence of a system for encoding machine instructions using special characters, proposed by John Mauchly. The coding system he proposed inspired one of his collaborators, Grace Murray Hopper. While working on the Mark-1 computer, she and her group had to face many problems and everything they came up with was for the first time. In particular, they came up with subroutines. And another fundamental concept of programming technique was first introduced by Hopper and her group: “debugging.”
In the late 40s, J. Mauchly created a system called “Short Code,” which was a primitive high-level programming language. In it, the programmer wrote down the problem to be solved in the form of mathematical formulas, and then, using a special table, translated character by character, converting these formulas into two-letter codes. Subsequently, a special computer program converted these codes into binary machine code. The system developed by J. Mauchly is considered one of the first primitive interpreters.

Already in 1951, Hopper created the world's first compiler and she also introduced this term. The Hopper compiler carried out the function of combining commands and, during the translation, organized subroutines, allocated computer memory, and converted high-level commands (at that time pseudocodes) into machine commands. “Subroutines are in the library (of the computer), and when you select material from the library, it is called compilation,” was how she explained the origin of the term she coined.

In 1954, a group led by G. Hopper developed a system that included a programming language and a compiler, which was later called Math-Matic. With Math-Matic successfully completed, Hopper and her team set about developing a new language and compiler that would allow users to program in a language similar to regular English. In 1958, the Flow-Matic compiler appeared. The Flow-Matic compiler was the first language for commercial data processing tasks.
Developments in this direction led to the creation of the COBOL language (Common Business Oriented Language). It was created in 1960. In this language, compared to Fortran and Algol, mathematical tools are less developed, but text processing tools and organization of data output in the form of the required document are well developed. It was intended as the primary language for mass data processing in management and business areas.

The mid-50s are characterized by rapid progress in the field of programming. The role of programming in machine commands began to decrease. New types of programming languages ​​began to appear, acting as an intermediary between machines and programmers. The first and one of the most widespread was Fortran (FORTRAN, from FORmula TRANslator - formula translator), developed by a group of IBM programmers in 1954 (first version). This language was focused on scientific and technical calculations of a mathematical nature and is a classic programming language for solving mathematical and engineering problems on a PC.
For the first high-level programming languages, subject orientation of the languages ​​was a characteristic feature.
Algol occupies a special place among programming languages, the first version of which appeared in 1958. One of the developers of Algol was the “father” of Fortran, John Backus. The name ALGOrithmic Language emphasizes the fact that it is intended for writing algorithms. Thanks to its clear logical structure, Algol has become a standard means of writing algorithms in scientific and technical literature.

In the mid-60s, Thomas Kurtz and John Kameny (employees of the mathematics department at Dartmouth College) created a specialized programming language that consisted of simple English words. The new language was called “Beginner All-Purpose Symbolic Instruction Code, or BASIC for short.” The year of birth of the new language can be considered 1964. Today, the universal BASIC language (which has many versions) has gained great popularity and is widespread among PC users of various categories all over the world. This was greatly facilitated by the fact that BASIC began to be used as the built-in language of personal computers, the widespread use of which began in the late 70s. However, BASIC is an unstructured language, and therefore is poorly suited for teaching quality programming. To be fair, it should be noted that the latest versions of BASIC for PCs (for example, QBasic) have become more structural and, in their visual capabilities, are approaching languages ​​such as Pascal.

The developers focused the languages ​​on different classes of tasks, tied them to one degree or another to a specific PC architecture, and implemented personal tastes and ideas. In the 60s, attempts were made to overcome this “discord” by creating a universal programming language. The first brainchild of this direction was PL/1 (Programm Language One), developed by IBM in 1967. This language claimed to be able to solve any problem: computing, text processing, accumulation and retrieval of information. However, it turned out to be too complex, the translator from it was not optimal enough and contained a number of undetected errors.
However, the line towards the universalization of languages ​​was supported. Old languages ​​were modernized into universal versions: ALGOL-68 (1968), Fortran-77. It was assumed that such languages ​​would develop and improve and begin to displace all others. However, none of these attempts were successful.

The LISP language appeared in 1965. The main concept in it is the concept of recursively defined functions. Since it has been proven that any algorithm can be described using a certain set of recursive functions, LISP is essentially a universal language. With its help, a PC can simulate quite complex processes, in particular, the intellectual activity of people.
Prolog was developed in France in 1972 to solve problems in “artificial intelligence.” Prologue allows you to formally describe various statements, the logic of reasoning, and forces the PC to give answers to the questions asked.
A significant event in the history of programming languages ​​was the creation of the Pascal language in 1971. Its author is the Swiss scientist Niklaus Wirth. Wirth named it after the great 17th-century French mathematician and religious philosopher Blaise Pascal, who invented the first adding device, which is why the new language was named after him. This language was originally developed as an educational language for structured programming, and, indeed, now it is one of the main languages ​​for teaching programming in schools and universities.

In 1975, two events became milestones in the history of programming - Bill Gates and Paul Allen announced themselves by developing their version of BASIC, and Wirth and Jensen released the classic description of the language “Pascal User Manual and Report”.

No less impressive, including financial, success was achieved by Philip Kahn, a Frenchman who developed the Turbo-Pascal system in 1983. The essence of his idea was to combine successive stages of program processing - compilation, link editing, debugging and error diagnosis - in a single interface. Turbo Pascal is not only a language and a translator from it, but also an operating shell that allows the user to conveniently work in Pascal. This language has gone beyond its educational purpose and has become a professional programming language with universal capabilities. Due to these advantages, Pascal has become the source of many modern programming languages. Since then, several versions of Turbo Pascal have appeared, the latest being the seventh.
Borland/Inprise completed the Turbo Pascal product line and moved on to release a visual development system for Windows - Delphi.

The C language (first version – 1972), which is very popular among developers of software systems (including operating systems), left a big imprint on modern programming. This language was created as an instrumental language for developing operating systems, translators, databases and other system and application programs. C combines both the features of a high-level language and a machine-oriented language, allowing the programmer to access all machine resources, which languages ​​​​like BASIC and Pascal do not provide.
The period from the late 60s to the early 80s was characterized by a rapid growth in the number of different programming languages ​​that accompanied the software crisis. In January 1975, the Pentagon decided to bring order to the chaos of translators and established a committee that was ordered to develop one universal language. In May 1979, the winner was announced - a group of scientists led by Jean Ikhbia. The winning language was christened Ada, in honor of Augusta Ada Levellace. This language is intended for the creation and long-term (long-term) maintenance of large software systems; it allows for parallel processing and real-time process control.

For many years, software was built on the basis of operational and procedural languages ​​such as Fortran, BASIC, Pascal, Ada, C. As programming languages ​​evolved, other, fundamentally different approaches to creating programs became widespread.
There are a large number of classifications of programming languages ​​according to various criteria. The most common classifications are:
 high-level (Pascal, BASIC) and low-level programming languages ​​(Assembler);
 strictly typed (Pascal) and loosely typed (BASIC);
 with and without support for object-oriented programming (C++), etc.

Let's consider another classification. Programming languages ​​are divided into:
1) Machine-oriented languages:
- machine languages;
- symbolic coding languages;
 auto codes;
- macro.
2) Machine-independent languages:
 problem-oriented languages;
- universal languages;
- interactive languages;
- non-procedural languages.

Machine-oriented languages

Machine-oriented languages ​​are languages ​​whose sets of operators and graphical means significantly depend on the characteristics of the PC (internal language, memory structure, etc.). Machine-oriented languages ​​have the following features:
 high quality of created programs (compactness and speed of execution);
 the ability to use specific hardware resources;
 predictability of object code and memory orders;
 to create effective programs, you need to know the command system and the operating features of this PC;
 the labor-intensive process of writing programs (especially in machine languages ​​and JSC), which is poorly protected from errors;
 low programming speed;
 the impossibility of directly using programs compiled in these languages ​​on other types of computers.
Machine-oriented languages ​​are divided into classes according to the degree of automatic programming.

Machine language

An individual computer has its own specific machine language (hereinafter referred to as ML), it is prescribed to perform specified operations on the operands they define, therefore ML is a command language. The command reports information about the location of the operands and the type of operation being performed.
In new PC models, there is a tendency to improve internal languages ​​in hardware to implement more complex commands that are closer in their functional actions to the operators of algorithmic programming languages.

Symbolic Coding Languages

Symbolic Coding Languages ​​(hereinafter referred to as SKL), just like ML, are command languages. However, operation codes and addresses in machine instructions, which are a sequence of binary (in internal code) or octal (often used when writing programs) digits, are replaced in YSC by symbols (identifiers), the writing form of which helps the programmer more easily remember the semantic content of the operation. This ensures a significant reduction in the number of errors when compiling programs.
Using symbolic addresses is the first step to creating a YASK. PC commands contain symbolic addresses instead of true (physical) addresses. Based on the results of the compiled program, the required number of cells for storing the initial intermediate and resulting values ​​is determined. The assignment of addresses, performed separately from the compilation of the program in symbolic addresses, can be carried out by a less qualified programmer or a special program, which greatly facilitates the programmer's work.

Autocodes

There are languages ​​that include all the capabilities of YSC, through the expanded introduction of macro commands - they are called autocodes.

In various programs there are some quite frequently used command sequences that correspond to certain procedures for converting information. The effective implementation of such procedures is ensured by their design in the form of special macro commands and the inclusion of the latter in a programming language accessible to the programmer. Macro commands are translated into machine commands in two ways - arrangement and generation. The staging system contains “skeletons” - a series of commands that implement the required function, indicated by a macro command. Macro instructions provide the transfer of actual parameters, which, during the translation process, are inserted into the “skeleton” of the program, turning it into a real machine program.
In a generation system, there are special programs that analyze the macro command, determine what function needs to be executed and form the necessary sequence of commands that implement this function.
Both of these systems use JSC translators and a set of macro commands, which are also autocode operators.
The developed autocodes are called assemblers. Service programs, etc., are usually written in assembly languages.

Macro

A language that is a tool for replacing a sequence of characters describing the execution of required computer actions into a more concise form is called a macro (replacement tool).
Basically, a macro is designed to shorten the recording of the original program. The software component that enables macros to function is called a macro processor. The macroprocessor receives the macro-defining and source text. The macroprocessor's response to a call is to issue an output text.
Macros can work equally with both programs and data.

Machine independent languages

Machine-independent languages ​​are a means of describing algorithms for solving problems and information to be processed. They are easy to use for a wide range of users and do not require them to know the specifics of organizing the functioning of a PC.
Such languages ​​are called high-level programming languages. Programs compiled in such languages ​​are sequences of statements structured according to the rules of viewing the language (tasks, segments, blocks, etc.). Language operators describe the actions that the system must perform after translating the program into ML.
Thus, command sequences (procedures, subroutines), often used in machine programs, are represented in high-level languages ​​by individual statements. The programmer was able not to describe in detail the computational process at the level of machine instructions, but to focus on the main features of the algorithm.

Problem-oriented languages

With the expansion of the areas of application of computer technology, the need arose to formalize the presentation of the formulation and solution of new classes of problems. It was necessary to create programming languages ​​that, using notations and terminology in this area, would make it possible to describe the required solution algorithms for the assigned problems; they became problem-oriented languages. These languages ​​are focused on solving specific problems and should provide the programmer with tools that allow them to briefly and clearly formulate a problem and obtain results in the required form.
There are a lot of problematic languages, for example:
- Fortran, Algol – languages ​​created for solving mathematical problems;
- Simula, Slang - for modeling;
- Lisp, Snoball - for working with list structures.

Universal languages

Universal languages ​​were created for a wide range of tasks: commercial, scientific, modeling, etc. The first universal language was developed by IBM, which became PL/1 in the sequence of languages. The second most powerful universal language is called ALGOL-68.

Conversational languages

The emergence of new technical capabilities has posed a task for system programmers - to create software tools that ensure rapid interaction between a person and a PC; they are called interactive languages.
This work was carried out in two directions. Special control languages ​​were created to provide operational impact on the completion of tasks, which were compiled in any previously undeveloped (non-dialog) languages. Languages ​​were also developed that, in addition to management purposes, would provide a description of algorithms for solving problems.
The need to ensure prompt interaction with the user required storing a copy of the source program in the computer memory even after receiving the object program in machine code. When making changes to a program using an interactive language, the programming system, using special tables, establishes the relationship between the structures of the source and object programs. This allows you to make the required editorial changes in the object program.
One example of conversational languages ​​is BASIC.

Non-procedural languages

Non-procedural languages ​​make up a group of languages ​​that describe the organization of data processed using fixed algorithms (tabular languages ​​and report generators), and languages ​​for communicating with operating systems.
Allowing you to clearly describe both the task and the actions necessary to solve it, decision tables make it possible to clearly determine what conditions must be met before moving on to any action. One decision table, describing a certain situation, contains all possible block diagrams of implementations of solution algorithms.
Tabular methods are easily mastered by specialists of any profession. Programs written in tabular language conveniently describe complex situations that arise during system analysis.
Programming languages ​​serve different purposes, and their choice is determined by user-friendliness, suitability for a given computer and a given task. And problems for a computer can be very diverse: computational, economic, graphic, expert, etc. This diversity of problems solved by a computer determines the variety of programming languages. In programming, the best results are achieved with an individual approach based on the class of the problem, the level and interests of the programmer.

History of the creation of the Basic and Visual Basic programming language

The Basic programming language was created in 1964 by two Dartmouth College professors, John Kenemi and Thomas Kurtz, to teach programming skills to students. The language turned out to be so simple and understandable that after some time it began to be used in other educational institutions. In 1975, with the advent of the first microcomputers, the Basic baton was taken up by Bill Gates and Paul Allen, the founders of Microsoft. It was they who created a new version of Basic for the first Altair computers (MITS Altairs), capable of running in 4KB of RAM. Over time, it was this version that turned into one of the most popular programming languages ​​in the world. On the way to the pinnacle of glory, Basic had many difficulties, which it always overcame with honor, and when the first personal computers IBM PC appeared, it became the standard in programming, but in the form of GW-Basic. Then there was Turbo Basic, QuickBasic, Basic PDS, but always when developing a new version of the language, compatibility with previous versions was maintained and a program written for almost the first Basic could well (with minor changes) work in subsequent versions of this language. But new times have come, and in the early 90s the Microsoft Windows operating system appeared with a new graphical user interface (GUI).

The life of programmers has become hell. To create a simple program, you had to write several pages of code: create menus and windows, change fonts, clear memory, “draw” buttons, etc. However, the advantages of the new interface were so undeniable that already the third version of this operating system became the de facto standard for a personal computer. At this time, several parallel projects were underway within Microsoft to create a new programming language for Windows. And in 1991, under the slogan “now even novice programmers can easily create applications for Windows,” the first version of the new Microsoft Visual Basic tool appeared. At that moment, Microsoft rather modestly assessed the capabilities of this system, targeting it primarily at the category of beginners and non-professional programmers. The main task then was to release to the market a simple and convenient development tool in the then fairly new Windows environment, programming in which was a problem even for experienced professionals. The programming system created by the Visual Basic developers made it possible to “step back” from the complex internal structure of Windows and create programs from “cubes”, like in a children's construction set. Menus, windows, lists, buttons, text input fields and other Windows interface elements were added to the program using simple drag&drop operations.

VB programmers created their first program within a few minutes of starting to learn this language! Moreover, Visual Basic allowed developers to create new “cube” objects that could also be used in programs along with standard ones. And although many C programmers quietly chuckled at Microsoft's attempts to make a simple and understandable tool for developing Windows programs, Visual Basic began its victorious march around the world, and nothing could stop this process. The final barriers fell in 1994 with the release of Visual Basic for Applications. It was at this time, after the inclusion of VBA in Microsoft Office, Basic began to turn into one of the main programming standards for Windows. For Microsoft, the Basic language is of particular importance; at one time, the development of a Basic version for the Altair 8800 computer marked the beginning of the programming career of its founders, Bill Gates and Paul Allen. Therefore, at one time - in 1989, when the time came to distribute the main directions of creating development environments in various programming languages ​​between various companies, Microsoft retained QuickBasic - an environment for developing programs in Basic, refusing, for example, further work on the language Pascal programming, leaving it to Borland, which, in turn, stopped work on its version of Basic (Pascal later became the Delphi language).

Originally intended as a toy, Microsoft's Visual Basic took the programming world by storm. Its popularity is due to two reasons: relative simplicity and productivity. VB programs are slower than their C/C++ counterparts, but they are still fast enough for many business purposes and require much less development time. Forms were the same effort-saving abstraction that VB offered to Windows programmers. The VB IDE made it possible to design windows graphically by dragging controls such as buttons and list boxes from the toolbar onto a form. Once you were happy with the appearance of the form, you could move on to the code side and write event handlers for each form control.

Developing an application in VB thus consisted of creating several forms that talked to each other and possibly consulted a database for the necessary information. The resulting form turned out to be a window, which offered a much more convenient way to use windowing techniques. VB has reduced errors by removing some hidden C/C++ syntax. Except in special cases, expressions were limited to a single line of code, and variables had to be declared and initialized on separate lines of code. The assignment and comparison operators used the same symbol, but VB grammar required that these operators be used in a way that made their intent clear.

Perhaps most importantly, there were no pointers - a requirement of Bill Gates since the first versions of Microsoft BASIC. Although pointers are useful because they allow direct access to memory at any address, their use is prone to errors if they are not used carefully. BASIC's requirement for grammatical simplicity stems from the fact that it was originally created as a language for instruction: "Beginner"s All-purpose Symbolic Instructional Code." VB version 6 is already a powerful language that can be used used to create distributed applications using COM components and Microsoft Transaction Server. Microsoft proposed a three-tier approach for client-server architectures in which thin user interfaces interacted with remote VB components to retrieve data from a database or another machine.

Using VBScript and VBA (VB for Applications), you can write scripts for web browsers and automate Microsoft Office applications. Moreover, VB6 can be used to create Active-X controls that work with Internet Explorer, although this is rarely done because it requires the VB runtime DLL to be installed on the Internet client machine. Beginning with VB5, VB programs were compiled to machine code, but they were based on the use of a DLL that provided commonly used functions and implemented VB's object capabilities. What's interesting is that the VB compiler uses multi-pass mode for translation, and ultimately relies on the Microsoft C++ compiler to produce machine code output after compiling into an intermediate language. The seeds of .NET are visible in this feature of VB - the use of a runtime library and a C++ backend.

History of the creation of the C# programming language

The C# language was born in June 2000 as a result of the painstaking work of a large group of Microsoft developers, led by Anders Hejlsberg. This man is known as the author of one of the first compiled programming languages ​​for IBM personal computers - Turbo Pascal. Probably, in the territory of the former Soviet Union, many experienced developers, and simply people who studied programming in one form or another at universities, experienced the charm and ease of use of this product. In addition, while working at Borland Corporation, Anders Hejlsberg became famous for creating the Delphi integrated environment (he led this project until the release of version 4.0).
It was no coincidence that the appearance of the C# language and the .NET initiative occurred in the early summer of 2000. It was at this moment that Microsoft prepared industrial versions of new component technologies and solutions in the field of messaging and data exchange, as well as the creation of Internet applications (COM+, ASP+, ADO+ , SOAP, Biztalk Framework). Undoubtedly, the best way to promote these new products is to create a toolkit for developers with their full support. This is one of the main goals of the new C# language. In addition, Microsoft could no longer expand the same tools and development languages, making them more and more complex to meet the conflicting demands of supporting modern hardware and maintaining backward compatibility with those products created in the early 1990s. during the first appearance of Windows. There comes a time when it is necessary to start from scratch in order to create a simple but complex set of languages, environments and development tools that will allow the developer to easily create modern software products.

C# and .NET are the starting point. To put it simply, .NET is a new platform, a new API for programming on Windows, and C# is a new language created from the ground up to work with that platform, and to take full advantage of the progress of development environments and our understanding of the principles object-oriented programming for the last 20 years.
It should be noted that backward compatibility is not lost. Existing programs will run, and the .NET platform was designed to work with existing software. Communication between components in Windows is now almost entirely done using COM. With this in mind, .NET has the ability to (a) create wrappers around existing COM components so that .NET components can talk to them, and (b) create wrappers around .NET components so that they look like regular COM components .

The authors of C# sought to create a language that combines the simplicity and expressiveness of modern object-oriented languages ​​(like Java) with the richness and power of C++. According to Anders Hejlsberg, C# borrows most of its syntax from C++. In particular, it contains such convenient data types as structures and enumerations (another descendant of C++ - Java - lacks these elements, which creates certain inconveniences when programming). C# syntactic constructs are inherited not only from C++, but also from Visual Basic. For example, C#, like Visual Basic, uses class properties. Like C++, C# allows operator overloading for types you create (Java does not support either feature). C# is actually a hybrid of different languages. At the same time, C# is syntactically no less (if not more) clean than Java, as simple as Visual Basic, and has almost the same power and flexibility as C++.

Features of C#:

A complete and well-defined set of basic types.
- Built-in support for automatic generation of XML documentation. Automatic release of dynamically allocated memory.
- Ability to mark classes and methods with user-defined attributes. This can be useful for documentation and can affect the compilation process (for example, you can mark methods that should only be compiled in debug mode).
- Full access to the .NET base class library, as well as easy access to the Windows API (if you really need it).
- Pointers and direct memory access, if needed. However, the language is designed in such a way that in almost all cases you can do without it.
- Support for VB style properties and events.
- Easy to change compilation keys. Allows you to obtain .NET component executables or libraries that can be called by other code in the same way as ActiveX controls (COM components).
- Ability to use C# to write dynamic ASP.NET web pages.

One area for which this language is not intended is time-critical and high-throughput programs, where it matters whether a loop takes 1000 or 1050 machine cycles to execute and resources need to be released immediately. C++ remains the best low-level language in this area. C# lacks some key features needed to create high-performance applications, such as inline functions and destructors that are guaranteed to execute at certain points in the code. This language is also actively used to create modern video games, for example, the game Battlefield 3 is partially written in C#, and entirely in .NET technology

Consisted of installing key switches on the front panel of the computing device. Obviously, only small programs could be written in this way.

With the development of computer technology, machine language appeared, with the help of which the programmer could set commands, operating with memory cells, fully using the capabilities of the machine. However, using most computers at the machine language level is difficult, especially when it comes to input/output. Therefore, we had to abandon its use.

For example, to read a block of data from a floppy disk, the programmer can use 16 different commands, each of which requires 13 parameters, such as the block number on the disk, the sector number on the track, etc. When the disk operation completes, the controller returns 23 values ​​reflecting the presence and types of errors that need to be analyzed.

"Words" in machine language are called instructions, each of which represents one elementary action for the central processor, such as, for example, reading information from a memory cell.

Each processor model has its own set of machine instructions, although most of them are the same. If Processor A fully understands the language of Processor B, then Processor A is said to be compatible with Processor B. Processor B will be said to be incompatible with Processor A if A has instructions that are not recognized by Processor B.

Throughout the 60s, demands for software development increased and programs became very large. People began to realize that creating software was a much more difficult task than they had imagined. This led to the development of structured programming. With the development of structured programming, the next advancement was procedures and functions. For example, if there is a task that is executed several times, then it can be declared as a function or procedure and simply called during program execution. In this case, the overall program code becomes smaller. Functions allow you to create modular programs.

The next advance was the use of structures, which led to classes. Structures are composite data types built using other types. For example, the structure of time. It includes: hours, minutes, seconds. The programmer could create a time structure and work with it as a separate structure. A class is a structure that has its own variables and functions that work with these variables. This was a very big achievement in the field of programming. Now programming could be divided into classes and tested not the entire program, consisting of 10,000 lines of code, but the program could be divided into 100 classes and tested each class. This made writing a software product much easier.

Assembly language

In the case when it is necessary to have an effective program, instead of machine languages, machine-oriented languages ​​that are close to them are used - assemblers. People use mnemonic commands instead of machine commands.

But even working with assembler is quite complicated and requires special training.

Structured programming involves precisely defined control structures, program blocks, no unconditional jump (GOTO) instructions, self-contained subroutines, support for recursion and local variables.

The essence of this approach is the ability to split a program into its component elements.

Also created functional(applicative) languages ​​(Example: Lisp - English. LISt Processing, 1958) and brain teaser languages ​​(example: Prolog - English) PROgramming in LOGic, 1972).

Although structured programming, when used, has produced outstanding results, even it fails when the program reaches a certain length. In order to write a more complex (and longer) program, a new approach to programming was needed.

OOP

As a result, the principles of object-oriented programming were developed in the late 1970s and early 1980s. OOP combines the best principles of structured programming with powerful new concepts, the basic ones being called encapsulation, polymorphism, and inheritance.

Examples of object-oriented languages ​​are Object Pascal, C++, Java, etc.

OOP allows you to optimally organize programs by breaking a problem into its component parts and working with each separately. A program in an object-oriented language, solving a certain problem, essentially describes a part of the world related to this problem.

An example of writing a program in different languages

High level language (Delphi)

X : = sin (y* Pi) + 1 ;

x86 assembler (coprocessor)

Fldpi fmul qword ptr [ Y] fsin fld1 fadd p st (1), st (0) fstp qword ptr [ X]

Machine code (hexadecimal, each command starts on a new line)

D9 EB DC 0D D0 97 40 00 D9 FE D9 E8 DE C1 DD 1D 98 97 40 00

Machine code (binary representation)

11011001 11101011 11011100 00001101 11010000 10010111 01000000 00000000 11011001 11111110 11011001 11101000 11011110 11000001 11011101 00011101 10011000 10010111 01000000 00000000

Links

Major programming languages ​​(IDE comparison story chronology)
Used
in developing
Academic
IEC 61131-3
Others
Esoteric
Visual

Wikimedia Foundation. 2010.

  • Aye-aye
  • Kabanov, Nikolai Alexandrovich

See what “History of Programming Languages” is in other dictionaries:

    History of the Python programming language- Python was conceived in the 1980s and its creation began in December 1989 by Guido van Rossum as part of the Center for Mathematics and Computer Science in the Netherlands. The Python language was conceived as a descendant of the ABC programming language, capable of processing... ... Wikipedia

    Chronology of programming languages- Lists of programming languages ​​By category Chronological Genealogical Chronology of programming languages ​​is a chronologically organized list of programming languages. Contents... Wikipedia

    Comparison of programming languages- This article should be Wikified. Please format it according to the article formatting rules. Conventions... Wikipedia

    A Brief History of the Development of Programming Languages- As computer technology developed, different programming techniques arose. At each stage, a new approach was created that helped programmers with the increasing complexity of programs. Contents 1 Beginning of development 2 Assembly language 3 Structure ... Wikipedia

    History of logic- studies the development of science about the forms and laws of correct thinking (logic). The emergence of logic as a developed analysis of the principles of inference relates exclusively to three local civilizations, namely: China, India and Ancient ... ... Wikipedia

    History of Linux- This article or section needs to be revised. Please improve the article in accordance with the rules for writing articles... Wikipedia

    History of free software- The phrase “Free Software”, or Free Software, refers to products distributed under liberal licenses that provide the user with more options than traditional software licenses... ... Wikipedia

It is very important to know the general history of programming languages ​​and the history of the development of known and unknown languages. In this article you will get acquainted with this, but first let’s remember “What is a programming language?”

Programming language is a system of notation and rules that allows you to write a program for solving a problem in the form of a sequential text in a form convenient for a person.

50s

In the fifties of the twentieth century, with the advent of vacuum tube computers, the rapid development of programming languages ​​began. Programming began with writing programs directly in the form of machine instructions (in codes, as programmers say). Computers, which at that time cost significantly more than the development of any program, required highly efficient code.

To make coding easier, machine-oriented was developed, which made it possible to write machine instructions in symbolic form. Assembly language depended on the instruction system of a particular computer. It was convenient enough for programming small tasks that required maximum execution speed.

However, large projects were difficult to develop in Assembly language. The main problem was that a program written in Assembly was tied to the architecture of a particular computer and could not be transferred to other machines. When the computer was improved, all programs in Assembly had to be rewritten anew.

Almost immediately with the advent of computers, high-level languages ​​were developed, i.e. languages ​​that do not depend on a specific architecture. To execute a program in a high-level language, it must first be translated into machine command language. A special program that performs such translation is called a translator or compiler.

The translated program is then executed directly by the computer. There is also the possibility of translating the program into an intermediate language that does not depend on the architecture of a particular computer, but, nevertheless, is as close as possible to the machine command language.

The intermediate language program is then executed by a special program called an interpreter. It is also possible to compile on the fly, when the executed program fragment is translated from an intermediate language into the machine command language immediately before execution.

In the mid-50s, under the leadership of John Backus, the high-level algorithmic programming language FORTRAN was developed for IBM. Despite the fact that there were already developments in languages ​​that converted arithmetic expressions into machine code, the creation of the FORTRAN language (FORmula TRANslator), which provided the ability to write a calculation algorithm using conditional statements and input/output operators, became the starting point of the era of high-level programming languages.

As an alternative to the FORTRAN language, originally aimed at the IBM architecture, ALGOL (ALGOrithmic Language) was developed under the leadership of Peter Naur in the late 50s. The main goal pursued by the developers of this language was independence from the specific architecture of the computer system.

In addition, the creators of the ALGOL language sought to develop a language convenient for describing algorithms and using a notation system close to that adopted in mathematics. FORTRAN and ALGOL were the first languages ​​focused on computational programming.

60s

In the late 60s, under the leadership of Nayard and Dahl, the Simula-67 language was developed, using the concept of user-defined data types. In fact, it is the first language to use the concept of classes.

70s

In the mid-70s, Wirth proposed the Pascal language, which immediately became widely used. At the same time, at the initiative of the US Department of Defense, work began on creating a high-level language called Ada - in honor of Ada Lovelace, a programmer and daughter of Lord Byron.

The creation of the language began with defining requirements and developing specifications. Four independent groups worked on the project, but they all used Pascal as a basis. In the early 1980s, the first industrial compiler for the Ada language was developed.

C development

The universal programming language was developed in the mid-70s by Denis Ritchie and Ken Thompson. The language became a popular systems programming language and was at one time used to write the kernel of the UNIX operating system.

The C language standard was developed by an ANSI working group in 1982. The International Standard for the C language was adopted in 1990. The C language formed the basis for the development of programming languages ​​and Java.

The C language made it possible to actually get rid of Assembler when creating operating systems. For example, almost all the text of the Unix operating system is written in C and, thus, does not depend on a particular computer.

The main advantage of C is its simplicity and the absence of pseudoscientific solutions. The mechanism for passing parameters to a function (by value only) is described simply and clearly. A programmer creating a C program always clearly understands how this program will be executed.

The concept of a pointer, static and automatic (stack) variables of the C language most closely reflect the structure of any modern computer, therefore C programs are effective and convenient for debugging.

Currently, the vast majority of programs are written in C and C++. The interface of any operating system (the so-called API - Application Program Interface), i.e. a set of system calls intended for application developers is usually a set of functions in the C language.

Along with algorithmic languages, languages ​​intended for processing business information, as well as artificial intelligence languages, developed in parallel. The first includes the COBOL (COmmon Business Oriented Language) language, and the second includes the LISP (LISt Processing) and Prolog languages.

The LISP language, developed in the 60s under the leadership of J. McCarthy, was the first functional list processing language that found wide application in game theory.

90s

In the 90s, with the spread of the Internet, the possibilities of distributed data processing expanded, which also affected the development of programming languages. Languages ​​focused on creating server applications have appeared, such as Perl, Document Description Languages, and XML.

The traditional programming languages ​​C++ and Pascal also underwent changes: a programming language began to mean not only the functionality of the language itself, but also the class libraries provided by the programming environment.

The emphasis was shifted from the specification of the programming languages ​​themselves to the standardization of the mechanisms for interaction of distributed applications. New technologies have appeared - COM and CORBA, which specify the interaction of distributed objects.

Areas of application of programming languages

Currently, programming languages ​​are used in a wide variety of areas of human activity, such as:

  • scientific computing (languages ​​C++, FORTRAN, Java);
  • system programming (languages ​​C++, Java);
  • information processing (languages ​​C++, COBOL, Java);
  • artificial intelligence (LISP, Prolog);
  • publishing activities (Postscript, TeX);
  • remote information processing (Perl, PHP, Java, C++);
  • description of documents (HTML, XML).

Based on the history of programming languages, we can say that over time, some languages ​​have developed, acquired new features and remained in demand, while others have lost their relevance and today are, at best, of purely theoretical interest.



 

It might be useful to read: