Assembly language
Throughout the 1950s, demands for software development increased and programs became very large. I had to write a lot of code, although the software was very simple: at that time, the design of the desktop was simpler than today, the programs worked with basic things, and the computer was just beginning to march victoriously. However, the programs became more and more confusing, their structure became more complicated because it was constantly evolving. computer technology. Then they began to use special programs that assembled programs from small pieces of code - assemblers. A new stage of development has begun.
This meant moving to a "procedural" paradigm from a "low-level" programming paradigm. These procedural languages used a step-by-step approach. In addition, they provided portability and could run on different machines. Further, programmers sought to find an even more logical approach to creating programs, which caused the birth of the “object-oriented” programming paradigm.
The chart below shows the major programming languages in chronological order. The most influential programming paradigms include procedural, structured, functional, logical, and object-oriented paradigms.
Now, when an efficient program was needed, instead of machine languages, closely related machine-oriented assembly languages were used. These included, for example, Autocode, since 1954 - IPL (predecessor of the LISP language) and, since 1955 - FLOW-MATIC (predecessor of the COBOL language). Now people began to use mnemonic commands instead of machine commands.
Procedural programming paradigm
A traditional model of computing, the procedural programming paradigm specifies a list of operations that a program must perform to achieve its final goal. It describes the steps that change the computer's memory state by providing operators such as assignment operators. This paradigm creates procedures, functions, subroutines, or methods by breaking tasks into small pieces, thereby allowing portions of the code to be reused to some extent throughout the program and making it easier for programmers to understand and maintain program structure.
But even working with assembler is quite complicated and requires special training. For example, for the Zilog Z80 processor, machine instruction 00000101 instructs the processor to decrement its B register by one. In assembly language this will also be written as DEC B.
High level languages
The next step was taken in 1954, when the first high-level language, Fortran, was created. FORTRAN - FORmula TRANslator), and after it some others, like LISP, ALGOL 58, FACT (another predecessor of the COBOL language). High level languages imitate natural languages by using some spoken language words and common mathematical symbols. These languages are more convenient for humans; with their help, you can write programs up to several thousand lines in length. Of course, this achievement was very valuable. With conditional words, it was possible, as is usual for a person, to express a complex software operation from bits much more simply. However, although easily understood in short programs, this language became unreadable and difficult to manage when it came to large programs. That is, simplicity was still lacking. The solution to this problem came with the invention of structured programming languages. structured programming language ), such as ALGOL (1958), Pascal (1970), C (1972).
However, it is still difficult to solve problems, especially when they are large and complex, since programming languages are not particularly close to the way people think or reason. Procedural programs are difficult to maintain, and it is not easy to reuse code when the program is large and has many procedures or functions. Moreover, if the modification has to be done in one of its states or conditions, it is difficult and time consuming. These shortcomings make this paradigm very expensive.
Structured programming paradigm
The structured programming paradigm can be considered a subset of the procedural programming paradigm. The structured programming paradigm is often associated with a top-down approach. This approach first breaks down the problem into smaller pieces. These parts further decompose, ultimately creating a collection of individual problems. Each problem is then solved one at a time. While this approach is generally successful, it causes problems later when changes must be made.
And the next achievement was the use structures, thanks to which we moved on to classes. Structures are composite data types built using other types. For example, the structure of time: it includes: hours, minutes, seconds. In turn, hours, minutes, and seconds - they are described using other, simpler and more elementary types. Instead of complex work, there are many types, each of which can have its own restrictions - and what is suitable for one type is prohibited in another - instead, the programmer could create a “time” structure and work with it as with a single type, where there are no exceptions and one format.
Functional programming paradigm
Since every change requires modification of the program, this approach minimizes the reuse of code or modules. The functional programming paradigm was created to model the problem rather than the solution, allowing the programmer to gain a high-level understanding of what needs to be computed rather than how. Thus, it emphasizes defining functions instead of executing a sequential list of instructions. Because each function is designed to perform a specific task, given its arguments, without relying on external state, the functional programming paradigm improves readability and maintainability.
In turn, a Class is a structure that has its own variables and functions that work with these variables. That is, it can be called a special environment, different from other classes. All class members are of the same type. See the article for more details.
However, since this paradigm more closely matches current hardware, such as von Neumann architecture, it may be less efficient and its use of time and space may be difficult to justify. Also, some things are harder to fit into a model where functions only take input and produce output.
Logic programming paradigm
Instead of specifying instructions on a computer, the logic programming paradigm allows logic to be expressed. So it's useful to deal with problems where it's not obvious what features should be there. In this paradigm, programmers specify a set of facts, such as statements or relations that are assumed to be true, as well as a set of axioms or rules, and use queries to the runtime to check whether certain relations hold and determine the answer by logical inference. This paradigm is popular for database interfaces, expert systems, and mathematical theorists.
In short, this achievement in the field of programming was very great. 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.
Structured programming involves precisely defined control structures, program blocks, no unconditional jump (GOTO) instructions, autonomous subroutines, support for recursion and local variables.
Object-oriented programming paradigm
In the following example, we are declaring facts about some domain. We can then ask questions about these facts, such as are siblings brother and brother? Sibling: - parent, parent parent: - father's parent: - mother-mother. father's father's father. Object-oriented programming is the newest and most widespread paradigm. It offers new ways of thinking to solve problems because its methods more accurately model how people solve problems. Traditionally, a program has been viewed as a logical procedure that accepts input. processes it and generates output.
The essence of this approach is the ability to split a program into its component elements.
Also created functional(applicative) languages (Example: Lisp - English. OOP combines best principles structured programming with powerful new concepts, the basic ones called
In contrast, the object-oriented programming paradigm focuses on modeling problems in terms of objects, called objects, that have attributes and behavior, and that interact with other objects using message passing.
The key characteristics of object-oriented programming are class, abstraction, encapsulation, inheritance, and polymorphism. A class is a template or prototype from which objects containing variables and methods are created and which specifies a user-defined data type. Abstraction separates the interface from the implementation. Encapsulation isolates data by wrapping it in different methods and allows the internal implementation of a class to be shared, defining what information in an object can be exchanged with others.
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.
Inheritance allows hierarchical relationships to be represented and refined. Polymorphism allows objects different types receive the same message and react differently. The object-oriented programming paradigm has many advantages over traditional ones. Because it emphasizes modular code through the concepts of abstraction and encapsulation, it facilitates a disciplined software development process, allows you to create safe programs by using the concept of data hiding and eliminating redundant code and defining new classes from existing ones effortlessly through inheritance, it creates improved reusability, extensibility, reliability and maintainability.
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.
Parallel programming paradigm
On single-core architectures, this paradigm is traditionally implemented through processes or threads spawned by a single program. However, due to the rapid growth multi-core processors modern hardware architectures have introduced a new way of implementing this paradigm to exploit the resulting parallelism.
Event-based programming paradigm
Events cause trigger functions to execute, which process them. Paradigms can be combined to gain the benefits of each. However, this also increases the complexity of the program. The programmer must weigh the advantages and disadvantages to determine whether it is beneficial to combine paradigms.
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.
Shifts between programming paradigms
The goal of a multi-paradigm language is to use constructs from different paradigms to make a program that fits the nature of a particular problem. This way, the found variable is never reassigned. Most problems can be solved by starting from a known state and reaching an unknown state. However, some of them can be solved more easily in reverse order, starting from an unknown state and reaching a known state due to the ability to keep track of facts that are already known.
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 standard means recording algorithms in scientific and technical literature.
This is called a bottom-up approach, and is mainly used by the object-oriented programming paradigm. In addition, some complex problems are easier to solve when they are broken down into many simple subproblems. This is the top-down approach that most structured programming paradigms follow.
The von Neumann architecture considers a single processor processing sequential tasks and has the following properties. Thus, in this type of architecture, the emphasis is on state-changing expressions, mainly using reads and assignments, which are best suited to the programming paradigm of a procedural language.
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 words in English. 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 a built-in language 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 latest versions BASIC for PCs (for example, QBasic) have become more structural and, in their visual capabilities, are approaching languages such as Pascal.
Moreover, it is difficult to find errors. These languages had syntax similar to that of English, improved control structures, and mathematical expressions that greatly improved efficiency. The procedural or structured paradigms that were currently being developed in fashion provided constant maintenance due to the existence of too many routines and global data. This required the development of object-oriented programming, which helped both end users and the software industry.
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.
This type of programming provided ways for analysts, designers, programmers, and end users to communicate, making it easier to develop larger software projects. In addition, objects can be divided between teams and worked in parallel, which significantly reduced development time. Because the object-oriented programming paradigm focused on writing modular code, it was easy to develop, maintain, and reuse chunks. These cost-effective features made it the ideal paradigm of the era.
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.
An exception is an error or event that occurs unexpectedly, such as division by zero or out of memory. Exception handling is a mechanism for eliminating these errors when they occur and greatly improves the reliability and fault tolerance of programs.
Exception-free handling mechanisms must use other methods to indicate and handle exceptions. The most common method is to have functions return "special values". If the return value of a function indicates that an exception occurred during the function call, the appropriate action is taken. However, this creates a number of problems. First, it results in programs that are difficult to read. Secondly, it increases the size and complexity of programs due to necessary checks.
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 the successive stages of program processing - compilation, editing links, 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 became the source of many modern languages programming. 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 access to all machine resources, which languages such as 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 (many years) maintenance of large software systems, 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 programming languages (Pascal, BASIC) and low level(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 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 one. 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, which correspond to certain information transformation procedures. 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, which analyze the macro command, determine what function needs to be performed 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., as a rule, are compiled 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 condensed 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 expanding areas of application computer technology there was a need 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 dialogue 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 of this computer and this 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 working in 4KB random access memory. 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 during development new version language remained compatible with previous versions and a program written for practically 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 an operating room appeared Microsoft system Windows with a new graphical user interface (GUI).
The life of programmers has become hell. To create a simple program, I 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 the third version of this operating system has become the de facto standard for personal computers. 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 handy tool developments in what was then still quite new Windows environment, programming in which presented a problem even for experienced specialists. 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 elements Windows interface 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 VBA was included in the Microsoft Office Basic is beginning to emerge as one of the major 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, in due 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 - the 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. Having received a satisfactory appearance forms, you could go 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 suggested using windowing techniques much more in a convenient way. 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 was a lack of signage - a requirement of Bill Gates since the first Microsoft versions 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" command code for beginners). VB version 6 is already powerful language, which can be 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 applications Office. Moreover, VB6 can be used to create Active-X controls that work in conjunction with Internet Explorer, although this is rarely done because it requires the client's web-based machine to have the VB runtime DLL installed. 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 Microsoft company has 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 promoting these new products is the creation of tools for developers with their full support. This is one of the main goals of the new C# language. In addition, Microsoft could no longer extend the same tools and development languages, making them more and more complex to meet conflicting support requirements modern equipment and ensuring backward compatibility with those products that were created in the early 1990s. during the first emergence 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 one Starting point. To put it simply, .NET is a new platform, a new API for programming on Windows, and C# is new language, built from the ground up to work with this platform, and to take full advantage of the advancements in development environments and our understanding of object-oriented programming principles over the past 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
