There are a lot of terms in programming. Not every specialist in this field knows the meaning of all the words used by his colleagues. What can we say about students or people far from this sphere? Let's look at the basic concepts and give them a definition that is understandable to the average person. So, what is this language - the one in which programmers communicate?
Relevance of the issue
Programming terms are used by people who do this professionally or who are interested in it as a hobby. There is a special jargon of the profession that allows people to briefly and succinctly convey their opinion to the listener, who is oriented in the topic of discussion, and convey maximum information. Some terms are recognized by the public and are widely used by professionals working with technical languages, while others are common only among a narrow circle of like-minded people. The terms used by the majority are especially interesting. They have found application not only in oral communication, but in written speech, in scientific papers and journalism devoted to the intricacies of writing technical code.
So let's get started!
It is difficult to determine which term needs to be deciphered first, and which words do not deserve attention at all. Perhaps, first, let's look at what register dependence is. In programming, the term denotes the connection of language expressions and individual elements (functions, variables) with writing. This is possible using capital and regular letters. There are case sensitive languages. The same word, written with a different case of letters, will have completely different meanings. If the system is case-insensitive, no matter how you write the letters, the meaning will not change. Among case-sensitive programming languages, the most famous representative of programming languages is JavaScript. PHP is considered to be somewhat case sensitive, but the phenomenon is partial.
Since it is impossible to talk about programming terms without considering the basic one, and since it was already mentioned above that it is possible to write code in a system that is case sensitive and not case sensitive, it is necessary to define what is meant by a “programming language”. To be fair, most ordinary people are sure that this term is the main one for the sphere. The phrase implies a formalized language that was created to write algorithms and programs. Through code they solve various problems using computer technology. All languages created for programming are artificial. Semantic and syntactic rules are strictly specified by man. There is no free interpretation characteristic of natural speech. All languages are divided into high-level and low-level.
About types
Any dictionary of programming terms explains what kind of language is called high-level. This word refers to programming tools designed to describe a problem in a form that is easily understood by humans. This tool is simple and convenient to use; the code creator can easily navigate the symbols. The language is independent of the internal technical codes used by the machine. A product created using a high-level language must first be translated into machine code before it becomes operational. For translation, interpreters and translators are used. High-level languages - "C", "Pascal" and many others.
If you consult a dictionary of programming terms, you will find out that low-level languages are usually used to work with a specific type of computer. Such a language reflects in detail the code used inside the hardware. Its perception is difficult for humans due to the specifics of its writing.
About types: what else?
All programming languages existing in our time are divided into algorithmic and non-algorithmic. The first type, as you can learn from any reference book demonstrating programming terms for beginners, includes symbolic collections, sets of rules used to fix a certain description. This is strictly unambiguous. As a rule, an algorithm is an element of a language system.
Non-algorithmic are varieties in which the text is an indication of the sequence of implementation of operations. The generated code is the starting material. On its basis, an algorithmic solution to the problem specified by the conditions is synthesized.
Formal and original
There are formal languages. This phrase denotes speech systems intended for programming, which are based on logical calculus. The foundation of a language can be a formal grammar. In any case, we are talking about a set of rules governing the construction of code. The alphabet is determined in advance, and the sequences available to the programmer are specified. All their diversity is the language as such.
Among the basic programming terms is "source language". This phrase is used to describe a language system intended for programming, used to write a program. It differs from the machine one, used by the unit to execute the code specified by a person. The source language can be high-level or low-level.
Machine types and more
Machine language in some terminologies is called absolute. This term refers to a system designed to format program code in a form that can be understood and executed by a specific computer.
Among the basic programming terms, “machine-oriented language” attracts attention. Sometimes, instead of this, the encoding system is called “machine-dependent”. The term denotes a variant of writing code where special attention is paid to the structure of the units through which the product will be executed. The programmer must take into account the characteristics of the machine with which he will work. In some cases, it is enough to remember the key parameters of the type of units on which the code is executed, in others it is necessary to customize the product for the specific device on which the programmer works.
Machine-independent - a language format designed for programmer work. His distinctive feature- structure. It has no connections with a specific computer or type of computer. The tools of this coding system make it possible to execute the program on any computer that has a relay system that works with the language used by the author.
Basic definitions
Among the terms and definitions in programming, variables definitely deserve attention. This concept is one of the most important and basic knowledge for the entire industry. It refers to containers designed to store information. This information is referred to as the value of the variable. Each object has an identifier and a name that allows it to be distinguished from others of its class. Using the name, you can make a request to a variable, which means that at any time you can obtain the value stored in this information container.
It is equally important to understand the meaning of the word “meaning”. In relation to the programming industry, it is divided into types. The value can be in characters, numbers, or boolean. A type refers to the entire set of values that can exist in a particular case. To set it, you can simply list the possible options, or you can create a rule that sets restrictions. If we are talking about logical value, then there are only two options for him: true or false. But the numerical set has no end, so it cannot be designated as a listing of all possible options. To determine this type, they resort to a rule with which they formulate individual elements.
Data and what it is
If a student is asked on an exam what programming term suggests an object designed to represent a value, they should say “variable.” To access it, access it through the identifier.
If the data is arranged in some sequence, it is called an array. Every such object is composite. A function is a block of code that has a name. Through its name it can be called to execute the main program.
A class is a description of an object. It is produced through the enumeration of properties formed by functions and variables. Variables are often called properties, functions are called methods. Formally, a class is a container that stores information about the qualities of a specific object. Through a constructor, a program can create an instance of a class. Its methods and properties are available through special parts of the code for the main program.
Terminology: "1C"
“1C” is the general name of a group of companies, known today to almost any domestic programmer and person more or less closely associated with this industry. The enterprises were created on the initiative of Nuraliev. They develop, publish, support software platforms and solutions created for the operation of ordinary enterprises: with their help, many business processes can be automated. The company publishes products whose names coincide with the name of the group of companies: “1C”.
So what does this developer do? His main area of activity is automation. If we turn to the basic terms of programming for beginners, we can find out that automation is the use of some software and equipment in order to free a person from a number of tasks. Software solutions are capable of collecting information, transforming and storing data, and outputting it in a form that is easy to understand. Automation can be viewed as broadly as possible. This version of interpretation involves assessing the phenomenon as the use of technology that excludes manual labor. Automation measures are aimed at transferring a maximum of tasks to machines and robots in order to free up the ordinary person.
Most reference books of programming terms in English contain the word administration. It can be translated into our language as “administration”. This concept is used both in the industry in general and in the work of 1C products in particular. In relation to this package, the word denotes the tasks and problems that the System Administrator. His task is to install the program, configure its operation, and interaction with other software solutions. Administration includes operations with the information base and user rights. In general, in the industry, this term means guaranteeing the normal functioning of equipment, a data transmission network in relation to a certain place or company.
Terms: official and not so
Directories usually contain the abbreviation AIS. This abbreviation denotes a software solution whose purpose is to optimize the workflow management process of interaction with certain information. AIS are created to simplify decision-making on the management of a certain object. Typically, a system is designed for several users who have different rights and tasks, and different areas of responsibility.
In reference books of programming terms in English there is always a wonderful word bug. In Russian it sounds like “bug”. The literal translation is “bug, bug.” This word has become extremely common in the last few decades, both in America, where it originated, and in the rest of the world. Belongs to the slang of this sphere. Bugs are mistakes made, improper functioning of a software product, code, or system. A bug causes an unpredictable result, an incorrect outcome, or incorrect program behavior. The legends telling about the appearance of this word are quite interesting. It is believed that one day the cause of the failure was a small bug that got into the car, due to which part of the microcircuit began to work incorrectly. Since then, all errors, first in hardware, and then in code, have been assigned this name.
Terms: what else?
In short reference books of programming terms in English, there is usually the concept of Dynamic Link Library. This phrase is translated into Russian as “a library intended for dynamic connection.” For short, it is called a DLL. It contains additional lower-level programs and resources designed to simplify the programmer’s work. The library contains all the modules previously created by the author of the program - this way they can be used over and over again without rewriting the blocks. A library file may contain procedures and resources. The dynamic type of library resource is common in classic Windows operating systems because it simplifies the optimization of not only program creation, but also its execution. A broader understanding of a library among programmers is a software collection or arrangement of all the codes available to the developer.
Another important term is implementation. They call it the process of infusing software, taking into account specific user conditions. The job of the setup personnel is to train the people who will be using the product to use it.
Continuing the topic
A quick reference book of programming terms in English usually includes the word integration. In Russian it is consonant with “integration”. This is the name given to the formation of mutual connections between components that previously existed and worked independently. Integration involves debugging the exchange of information between objects, so that the total amount of information can then be effectively processed.
ITS or information technology support is the term programmers use to refer to end-user support. Those responsible for this advise clients and teach them how to use the development. This work includes all the methods by which the user can make the most of the tool given to him, developed by the programmer.
Work: everything is serious
Another important term is object-oriented programming. This phrase denotes a methodology that involves representing a product as a set of certain objects. OOP is a system in which each object that forms the final code is an instance belonging to a class. There is a hierarchical system of inheritance of qualities and characteristics.
OOP products are software solutions designed for a specific user and used by him for his own benefit. Most of these products are equipped with a report generation function. A report is a reflection of current information about current operations. The programmer's task is to set a data output layout that would be understandable to the user.
Reports can be generated by very small programs created by programmers for small enterprises, offices or even departments of government agencies. Reports are equally important for large products and projects - e.g. operating systems. In short, this result of programmers’ work is called OS. The abbreviation, present in most dictionaries dedicated to terms related to programming, is described as software that can run the hardware of a particular machine. The OS is the connection between the hardware aspect and the programs loaded into memory. Nowadays, users most often have different versions of Windows OS. The second most common system is Linux.
And who is the essence?
Don't forget about one of the basic programming terms (web and not only): programmer. Indeed, you need to be aware of the words used within the field, but also the most general concepts also deserve attention. A programmer is usually called a professional who is responsible for the code generation workflows. His areas of expertise include solution configuration and support of developed software.
A programmer works on a software product. The term refers to a program that is officially published. It is accompanied by a package of documentation, including a registration confirmation form and a detailed description of use intended for the end client.
The key to any program is the program code. In programming terms in English, it is called source code. This is the name for a symbolic, verbal set that obeys the rules of the chosen language. The process of working in this language is software development. The programmer who deals with it creates a certain component of a product (already existing or completely new). In addition to programming itself, development also involves testing activities to determine the functionality and quality of work, and the formation of documentation support.
About the analysis
Among the terms familiar to those who speak different programming languages is “system analysis.” The phrase presupposes a set of tools and techniques necessary to study a certain information system. Analysis is used to design such a solution.
Responsibility for the workflow is assigned to the systems analyst. This is a professional who specializes in system analysis in a specific strictly limited area or sphere. He formulates the requirements for the information system that is being worked on. The analyst's task is to determine what qualities the application software should have.
There are many different methods and approaches used in work, and programming terms have been developed for all of them (web as well). In particular, an important approach is the spiral analytical method, which reflects the software life cycle. It involves the inclusion of system analysts in the work, and not just programmers and testing specialists. The term denotes such an approach to the development of software and the implementation of a prepared solution, within the framework of which the primary functionality of the product gradually becomes broader and broader through additional solutions.
Curious terms
It has already been described above what the terms “low-level programming language” and “high-level” mean. Usually the meaning of these phrases is known to any student who is just beginning his studies in a thematic specialty. But not every beginner in this field knows what they mean when they say “IP telephony” - such a term hides the possibility of telephone connections for users via the World Wide Web.
Another word that not every beginner in this field knows is ARIS. This acronym refers to a concept as applied to modeling product workflows. The approach involves a combination of practice, the theory of some enterprise, communication technologies and software. The abbreviation is used to indicate software solution, released under that name. It was created to implement the agreed upon concept.
People involved in IT technologies know what the term “low-level programming language” means. But what kind of technologies are these? Not every layman can give a clear explanation of the term. Officially, IT is a complex field that includes numerous approaches, techniques, and techniques developed for using computers to work with information. Using this technology, IT specialists can process and receive information, store and analyze information, and use it to their advantage.
Curious Area: Linear Programming
This class involves solving single criterion optimization problems. The variables used in the work are continuous, cannot be negative, and the function is linear. There may be constraints that are also linear and can be expressed as equality or inequality. There are no specialized restrictions on the value of variables. The formation of this direction was due to the works of Danzig, Koopmans, and Neumann. The term “linear programming” first appeared in 1951. The relevance of the approach was explained by the need to work on optimization problems in addition to classical ones. The need itself was recognized quite a long time ago, but the theory that laid the foundations for this programming appeared only after the Second World War.
The term was developed by Danzig and Koopmans. It is believed that the first works devoted to this issue belong to Kantorovich, who published his works in the thirties of the same century in the Soviet Union. Danzig himself recognized Kantorovich as the first, since it was this scientist who discovered the possibility of formulating numerous production problems in mathematical terms. The achievements made by scientists in this area have allowed us to take a fresh look at the optimization of problems of various classes. Today, such approaches are used in training professionals in various fields.
About popular languages: "C"
Speaking about key terminology, we should consider it in relation to one of the most popular programming languages these days - C. The terms were combined during the compilation of numerous dictionaries. Many of the concepts described above apply to this language as well. It is one of the statically compiled ones. It is a typed development language designed to solve common problems. Work on its creation began in 1969. It is believed that the author of "C" is Ritchie, who worked at Bell Labs. At first it was used for the Unix OS, but gradually became available for a variety of platforms. According to the author of the language, the most active work on its formation was carried out in 1972. In 1973, the product was completed and presented to the developers. The name of the new project was chosen because the elements of the new product were based on the pre-existing language "Bi".
Object-oriented programming is a programming method that closely resembles our behavior. It is a natural evolution of earlier innovations in programming language development. Object-oriented programming is more structured than all previous developments concerning structured programming. It is also more modular and more abstract than previous attempts to abstract data and move programming details internally.
One of the most important principles of object-oriented programming is that the programmer must think about the code and the data together when developing a program. Neither code nor data exists in a vacuum. Data drives the flow of code, and code manipulates the images and values of the data. If your code and data are separate elements, then there is always the danger of calling the correct procedure with the wrong data or the wrong procedure with the correct data. It's up to the programmer to make sure these elements match, and while Pascal's strong typing helps, the best he can do is point out the mismatch. Pascal never says anything about what actually exists together. If it is not marked with a comment or is not something you remember all the time, then you are playing with fate. The object synchronizes code and data by jointly constructing their descriptions. In reality, to get the value of one of the fields of an object, you call a method related to this object, which returns the value of the desired field. To assign a value to a field, you call a method that assigns this field new meaning.
The application is assembled from many elements: forms, program modules, external libraries, pictures, icons, etc. Each element is placed in a separate file and has a strictly defined purpose. The collection of all the files needed to create an application is called a project. The compiler processes the project files sequentially and builds an executable file from them.
The main project files can be divided into several types: Form description files - text files with the DFM extension that describe forms with components. These files remember the initial property values you set in the Properties window. Program module files are text files with the PAS extension containing source program codes in the Delphi language. In these files, you write methods for handling events generated by forms and components.
Main project file - text file with DPR extension, containing the main program block. The project file includes all the software modules used and contains statements to run the application. The Delphi environment creates and controls this file itself. A Delphi project is a set of software units - modules. One of the modules is the main one, containing instructions that begin the execution of the program.
The main application module is built entirely by Delphi. The main module is a file with the extension dpr. In order to see the text of the main application module, you need to select the View Source command from the Project menu. Each form in the project has its own program module (unit), containing all form-related declarations and event processing methods written in Delphi. Software modules are located in separate files with PAS extension. Their number may exceed the number of forms. Why? Because in some cases, program modules may not belong to forms, but contain auxiliary procedures, functions, classes, etc.
Never change the name manually. The Delphi environment requires that the module name be the same as the file name, so if you want to rename a module, save it to a file with a new name using the menu command File | Save As.... The Delphi environment itself will substitute a new name after the word unit. After that, remove the old module. The content of the interface section of the module (interface) begins with the connection of standard modules of the VCL library, which define frequently called routines and classes of components placed on the form. The Delphi environment generates a list of modules without your participation and automatically updates it when you add new components to the form. However, the list of connected modules can be changed directly in the code editor (manually). A module begins with the word unit, followed by the name of the module. The module consists of the following sections:
- · interface;
- · implementation;
- · initialization.
The interface section (begins with the word interface) tells the compiler which part of the module is accessible to other program modules. This section lists (after the word uses) the library modules used by this module. There is also a Delphi-generated form description that follows the word type.
The implementation section opens with the word implementation and contains declarations of local variables, procedures and functions that support the operation of the form.
The implementation section begins with a directive ($R *.DFM), indicating to the compiler that the form description should be used in the process of generating the executable file. The form description is located in a file with the dfm extension, the name of which matches the name of the module. The form description file is generated by the Delphi environment based on appearance forms.
The directive ($R *.DFM) is followed by event handling procedures for the form and its components. The programmer can also place other procedures and functions here.
The initialization section allows you to initialize module variables. The instructions in the initialization section are located after the implementation section (descriptions of all procedures and functions) between begin and end. If the initialization section does not contain instructions (as in the example given), then the word begin is not specified.
It should be noted that a significant number of module instructions are generated by Delphi. Delphi, analyzing the programmer's actions to create the form, generates a description of the form class (after the word type). In order for the compiler to know which specific files are included in the project, some kind of organizing principle is necessary. And it really is. This is a so-called project file with a DPR extension (short for Delphi Project). He represents the main program file in the Delphi language, which connects all module files included in the project using the uses operator. There is only one DPR file for each project. When we use the command File | New | Application we start developing a new application, the Delphi environment automatically creates a project file. As new forms are created, the contents of this file are modified automatically. When we finish our work and are ready to compile the project, the DPR file will contain a list of program modules that will be supplied as input to the compiler.
The concept of a component is fundamental to the Delphi environment. Without components all the benefits visual development applications disappear and there is nothing to talk about. The Delphi developers took care to include easy-to-use components in the library that implement the appropriate dialog boxes. They are posted on the Dialogs page.
Basic Programming Concepts
Basic definitions, properties of the algorithm
Flowchart Language
Basic algorithm structures: following, branching, repetition
Pseudocode language
Basic definitions
An algorithm (on behalf of the scientist al-Khwarizmi (pers. یمزراوخ)) is an exact set of instructions that must be executed to solve a given problem in a finite number of steps.
A command is an elementary instruction that requires the execution of some action.
Operators are actions prescribed by a command.
A program is data, its description and an algorithm written in a programming language.
Programming– the process of creating programs.
Programming language– a formalized language for writing programs. All programming languages are artificial; their syntax and semantics are strictly defined.
Basic definitions
Algorithm properties
Discreteness is the ability to split the algorithm into separate elementary actions. The algorithm represents the process of solving a problem as a sequence of steps. To complete each epic, you need certain time, i.e. the transformation of source data into results occurs discretely in time.
Certainty (determinism)– ensuring the unambiguity of the result during repeated calculations with the same initial data. Each rule of the algorithm must be clear and unambiguous, excluding the possibility of distortion or ambiguous interpretation.
Effectiveness (finiteness, finitude)– obligatory obtaining of the result in a finite number of steps. The inability to obtain a result indicates that this algorithm inapplicable to solve the problem at hand.
Mass scale – the possibility of obtaining results for a certain class of problems that differ in the initial data ( range of applicability of the algorithm). An algorithm for solving a problem should be developed in a general form for a certain class of similar problems.
Forms of representation of algorithms
Forms of representation of algorithms
Verbal (textual)– recording the algorithm in natural language. This form is used only at the initial stages of algorithm development, since for complex algorithms the description becomes too cumbersome and obscure.
Graphic (block diagram) – a graphic representation of the algorithm in the form of a sequence of interconnected blocks (symbols), each of which corresponds to the execution of one or more operators. This form is the most visual and compact.
Programmatic – recording an algorithm in the form of text in a programming language.
Pseudocodes are a recording of an algorithm in a human-oriented algorithmic language. This form is a semi-formalized description of algorithms, including both elements of a programming language and natural language phrases, generally accepted mathematical notations, etc.
Forms of representation of algorithms
An example of a verbal method of writing an algorithm for solving a quadratic equation ax²+bx+c=0
Set equation coefficients a, b, c
Calculate the discriminant using the formula d=b²− 4ac
If the discriminant is less than zero, then output the answer “No roots” and stop (end of the algorithm); otherwise, continue executing the algorithm;
Calculate the roots of the equation using the formulas x1 =(− b+√d)/2a; x2 =(− b− √d)/2a;
Output the obtained values as an answer. End of the algorithm
Flowchart Language
Some conventional graphic symbols of flowcharts
Symbol name |
Designation and example of filling Explanation |
|||
Beginning-end |
Beginning or end |
|||
algorithm, input or |
||||
exit to subroutine |
||||
Data processing |
||||||
(calculation, |
||||||
forwarding, etc.) |
||||||
Flowchart Language
Some conventional graphic symbols of flowcharts (continued)
Symbol name |
Designation and example of filling |
Explanation |
|||||||||
Predefined |
Calling a procedure |
||||||||||
calculations by |
|||||||||||
subroutine |
|||||||||||
Condition check |
|||||||||||
MINISTRY OF SCIENCE AND EDUCATION OF THE RUSSIAN FEDERATION
KAZAN STATE
FINANCIAL AND ECONOMIC INSTITUTE
Department of Mathematics and Economic Informatics
Concept of programming. Programming languages
Completed by: Molotov L.A.
Checked: Assoc. Kodolova I.A.
Kazan 2010
Introduction 3
1. Programming Basics 4
1.1.The concept of programming 4
1.2.Programming paradigms 5
1.3.Programming technology tools 8
2. Programming languages 11
2.1. Concept of programming language 11
2.2. Classification of programming languages 14
2.3. Description of some programming languages 17
3. Java 22 programming language
3.1. Java 22 Language Overview
3.2.The process of creating a Java program 23
3.3. Advantages of Java 25
Conclusion 28
List of sources used 29
Introduction
When you study a subject, you think that you know it; when you can write about it, you become more confident in your knowledge; Confidence increases when you can teach it to someone else; and completely confident when you start programming. Alan.J.Perlis
Until the mid-60s, computers were overly expensive machines that were used only for specific tasks and performed only one task at a time.
The programming languages of this era, like the computers they were used on, were designed for specific tasks, such as scientific computing. Since machines were expensive and slow, computer time was also expensive - so the speed of program execution came first.
However, during the 60s, the price of computers began to fall so that even small companies could afford them; The speed of computers kept increasing, and the time came when the creators of programming languages began to think more and more about the convenience of writing programs, and not just the speed of their execution.
At the dawn of computerization, machine language was the only language bigger man I didn’t come up with it by then. To save programmers from the rigors of machine programming language, high-level languages (i.e., non-machine languages) were created. “Small” (atomic) operations performed directly by machine devices were combined into “larger”, high-level operations and entire constructs, with which make it much easier and more convenient for a person to work. Thus, programming made a colossal breakthrough: new languages became a kind of connecting bridge between humans and the machine language of the computer.
Progress computer technology determined the process of the emergence of new diverse sign systems for recording algorithms (programming languages) and the development of the programming process as a whole.
1. Programming Basics
1.1. Programming concept
Term programming means the process and art of creation computer programs using special programming languages.
In the general sense of the word, programming is a formalization of a predetermined state, in response to an event, realized by means of mathematics or natural sciences.
In the narrow sense of the word, programming is considered as coding algorithms in a given programming language. In a broader sense, programming is the process of creating programs, that is, software development.
Programming includes:
· Design - development of a set of algorithms
· Coding and compilation - writing the source code of a program and converting it into executable code using a compiler
· Testing and debugging - identifying and eliminating errors in programs
· Testing and delivery of programs
· Escort
Different programming languages support different programming styles (called "programming paradigms"). Part of the art of programming is choosing one of the languages that best suits the problem at hand. Different languages require different levels of attention to detail from the programmer when implementing an algorithm, often resulting in a trade-off between simplicity and performance (or between programmer time and user time).
The only language directly executed by the processor is machine language (also called "machine code"). As already mentioned, initially, all programmers worked out every little detail in the machine code, but now this difficult work is no longer done. Instead, programmers write source, and the computer (using a compiler, interpreter or assembler, which will be discussed a little later) translates it, in one or more stages, specifying all the details, into machine code, ready for execution on the target processor. However, in some languages, interpreted binary "virtual machine" code, also called byte-code, is generated instead of machine code. This approach is used in Forth, Lisp, Java ( given language Chapter 3 of the abstract is devoted).
Now that we know a little about the concept of “programming,” we can move on to the material part of the process of creating programs. This, of course, is technical (hardware) programming support - a set of electrical, electronic and mechanical components automated systems constitutes their technical support (as opposed to software, which is the software of automated systems). For example, electronic Calculating machine(computer) or computer - a set of technical and software tools based on the use of electronics and intended for automatic or automated data processing in the process of solving computational and information problems.
1.2. Programming Paradigms
At the heart of a particular programming language is a certain guiding idea that has a significant impact on the style of the corresponding programs. Depending on the purpose and/or method of writing programs, they are distinguished paradigms(also known as approaches or technologies)programming :
Structured programming- programming methodology based on a systems approach to analysis, design and implementation of software. This methodology was born in the early 70s and turned out to be so viable that it is still the main one in a large number of projects. The basis of this technology is the following:
· A complex task is broken down into smaller, functionally better manageable tasks. Each task has one input and one output. In this case, the control flow of the program consists of a set of elementary subtasks with a clear functional purpose.
· Simplicity of control structures used in the task. This provision means that logically the task should consist of a minimal, functionally complete set of fairly simple control structures. An example of such a system is the algebra of logic, in which each function can be expressed through functional complete system: disjunction, conjunction and negation.
· Program development should be carried out in stages. At each stage, a limited number of clearly defined tasks must be solved with a clear understanding of their meaning and role in the context of the entire task. If such understanding is not achieved, this indicates that this stage too big and needs to be broken down into more basic steps.
Modular programming concept. Same as for structural technology programming, the concept of modular programming can be formulated in the form of several concepts and provisions:
· Functional decomposition of a task - breaking a large task into a number of smaller, functionally independent subtasks - modules. The modules are interconnected only by input and output data.
· Module is the basis of the concept of modular programming. Each module in a functional decomposition is a “black box” with one input and one output. The modular approach makes it possible to painlessly modernize the program during its operation and facilitates its maintenance. Additionally, the modular approach allows you to develop parts of programs of one project on different languages programming, and then, using packaging tools, combine them into a single boot module.
· Implemented solutions should be simple and clear. If the purpose of the module is not clear, then this indicates that the decomposition of the initial or intermediate task was not carried out with sufficient quality. In this case, it is necessary to analyze the task again and, possibly, carry out an additional division into subtasks. If there are complex places in the project, they need to be documented in more detail using a well-thought-out comment system. This process must be continued until you really achieve a clear understanding of the purpose of all the modules of the task and their optimal combination.
· The purpose of all module variables must be described using comments as they are defined.
Object-oriented programming (OOP). The idea of OOP is the desire to connect data with the procedures that process this data into a single whole - an object. OOP is based on three essential principles, giving objects new properties. These principles are encapsulation, inheritance and polymorphism.
· Encapsulation - combining data and algorithms for processing this data into a single whole. In OOP, data are called object fields, and algorithms are called object methods.
· Inheritance is the ability of objects to generate their descendants. A child object automatically inherits all fields and methods from its parents, can supplement objects with new fields and replace (override) parent methods or supplement them.
· Polymorphism is the property of related objects (that is, objects that have one common parent) to solve problems of similar meaning in different ways.
There are other programming technologies that should also be discussed a little.
Application programming- development and debugging of programs for end users, such as accounting, word processing, etc.
System Programming- development of general software tools, including operating systems, auxiliary programs, software packages for general system purposes, for example: automated control systems, database management systems, etc.
Declarative(logical, production) programming is a programming method designed to solve artificial intelligence problems. In this context, the program describes the logical structure of solving a problem, indicating primarily what needs to be done, without going into detail about how it is done. Programming languages like Prolog are used.
Parallel programming- development of programs that ensure simultaneous (parallel) execution of operations related to data processing.
Procedural(procedural-oriented) programming is a programming method in which programs are written as lists of sequentially executed instructions. In this case, procedure-oriented programming languages are used.
Functional programming- a programming method based on dividing the algorithm for solving a problem into separate functional modules, as well as describing their connections and the nature of interaction. The most widely used languages for functional programming are HOPE and ML. Elements of functional programming are also implemented in other languages, such as C.
Heuristic programming- a programming method based on modeling human mental activity. It is used to solve problems that do not have a strictly formalized algorithm or are associated with incomplete source data.
1.3. Programming Technology Toolkit
Finally, to fully understand the principle of a programming system, consider programming technology tools, i.e. a set of programs that provide technology for development, debugging and implementation software products.
Currently, the area related to the technology of creating software products is rapidly developing. This is due to the transition to industrial technology for program production, the desire to reduce time, labor and material costs for the production and operation of programs, and to ensure a guaranteed level of their quality.
Within these areas, the following groups of software products have been formed:
1. application creation tools(a set of languages and programming systems, as well as various software packages for debugging and supporting created programs.), including:
· local tools that ensure the implementation of individual work on creating programs; include programming languages and systems, as well as instrumental environment user;
· integrated environments for program developers, ensuring the implementation of a set of interrelated works on creating programs, increasing the productivity of programmers;
2. CASE technology(Computer - AidedSystem Engineering), presenting methods of analysis, design and creation software systems and designed to automate development and implementation processes information systems.
I would like to dwell on CASE technologies in more detail, because... the idea of them is associated in our minds with something that has nothing to do with ordinary programming.
CASE technology tools are divided into two groups:
· implementations built into the system - all design and implementation decisions are tied to the selected database management system (DBMS);
· system-independent implementations - all design decisions are focused on unifying the initial stages life cycle and means of documenting them, provide greater flexibility in the choice of means of implementation.
The main advantage of CASE technology is support for teamwork on a project due to the ability to work in local network developers, export/import of any project fragments, organizational project management.
Within the framework of CASE technologies, the entire project is supported, not just its program codes. Project materials prepared in CASE technology serve as tasks for programmers, and programming itself rather comes down to coding - translation of data structures and methods for processing them into a specific language, if automatic code generation is not provided.
Most CASE technologies also use the “prototyping” method for quick creation programs in the early stages of development. Code generation of programs is carried out automatically - up to 90% of object codes and texts are in high-level languages, and the most commonly used languages are Ada, C, and Cobol.
Today, Rational Rose from Rational Software Corporation is considered the world's leading CASE system. Rational Rose aims to create modules using the Unified Modeling Language (UML). The latest version of this company's CASE system is already being widely used to create commercial software and supports the popular programming languages Java, C++, Smalltalk, Ada, Visual Basic and Forte.
Using such technologies, you can interactively develop the architecture of the application being created, generate its source code, and simultaneously work on documenting the system being developed.
Finally, having considered almost all aspects of the programming process, we move on to the most significant component - programming languages. “For machines natural languages are not natural,” the American programmer Alan J. Perlis once said. We will prove the correctness of his statement in the next chapter.
2. Programming languages
2.1. Concept of programming language
The process of computer operation consists of executing a program, that is, a set of very specific commands in a very specific order. The machine form of the instruction, consisting of zeros and ones, indicates exactly what action the central processor should perform. This means that in order to give the computer a sequence of actions that it must perform, you need to specify a sequence of binary codes for the corresponding commands. Machine code programs consist of thousands of instructions. Writing such programs is a difficult and tedious task. The programmer must remember the combination of zeros and ones of the binary code of each program, as well as the binary codes of the data addresses used in its execution. It is much easier to write a program in some language that is closer to natural human language, and entrust the work of translating this program into machine codes to a computer. This is how languages developed specifically for writing programs - programming languages.
Programming language is a special language in which commands are written to control a computer. Programming languages are designed to make it easier for people to read and write for computers, but they must then be translated (by a translator or interpreter) into machine code, which alone can be executed by the computer. Programming languages can be divided into high-level languages and low-level languages.
Low level language is a programming language designed for a specific type of computer and reflecting its internal machine code; Low-level languages are often called machine-oriented languages. They are difficult to convert for use on computers with different central processors, and is also quite difficult to learn since it requires a good knowledge of the internal workings of a computer.
High level language is a programming language designed to satisfy the programmer's requirements; it does not depend on the internal machine codes of any type of computer. High-level languages are used to solve problems and are therefore often called problem-oriented languages. Each high-level language command is equivalent to several commands in machine codes, so programs written in high-level languages are more compact than similar programs in machine codes.
Language creators interpret the concept of programming language differently. Among the communities of places recognized by most developers are the following:
Function: A programming language is intended for writing computer programs that are used to transmit instructions to a computer to perform a particular computing process and organize the control of individual devices.
Task: A programming language differs from natural languages in that it is designed to transmit commands and data from a person to a computer, while natural languages are used only for communication between people. In principle, we can generalize the definition of “programming languages” - this is a way of transmitting commands, orders, clear guidance for action; whereas human languages also serve to exchange information.
Execution: A programming language can use special constructs to define and manipulate data structures and control the computation process.
Since the creation of the first programmable machines, humanity has already come up with more than two and a half thousand programming languages. Every year their number is replenished with new ones. Some languages are used only by a small number of their own developers, while others become known to millions of people. Professional programmers sometimes use more than a dozen different programming languages in their work.
But creating a language convenient for writing programs is not enough. Each language needs its own translator. Such translators are special translator programs.
Translator is a program designed to translate a program written in one programming language into a program in another programming language. The translation process is called translation. The texts of the source and resulting programs are located in the computer's memory. An example of a translator is a compiler.
Compiler is a program designed to translate a program written in a language into a machine code program. The process of such translation is called compilation.
The compiler creates the finished result - a program in machine code. This program is then executed. Compiled version original program can be saved to disk. To re-execute the original program, the compiler is no longer needed. It is enough to load the previously compiled version from the disk into the computer memory and execute it.
There is another way to combine the processes of translation and program execution. It's called interpretation. The essence of the interpretation process is as follows. First it is translated into machine codes, and then the first line of the program is executed. When the execution of the first line is completed, the translation of the second line begins, which is then executed, and so on. This process is controlled by an interpreter program.
Interpreter is a program designed for line-by-line translation and execution of the original program. This process is called interpretation.
The translation process includes checking the source program for compliance with the rules of the language used in it. If errors are detected in the program, the translator enters a message about them on the output device (usually on the display screen).
The interpreter reports the errors it finds after translating each line of the program. This greatly simplifies the process of finding and correcting errors in the program, but significantly increases the broadcast time. The compiler translates the program much faster than the interpreter, but reports the errors it finds after the entire program has finished compiling. Finding and correcting errors in this case is more difficult. Therefore, interpreters are designed mainly for languages intended for teaching programming and are used by novice programmers. Most modern languages are designed for developing complex software packages and are designed to be compiled.
Sometimes the same language can be used by both the compiler and the interpreter. Such languages include, for example, BASIC.
2.2. Classification of programming languages
If you have noticed, several individual names of programming languages have already been mentioned in the text. But before describing them in more detail, it is necessary to classify them into groups for ease of perception.
Firstly this machine-oriented languages, i.e. languages, the sets of operators and visual means of which significantly depend on the characteristics of the computer (internal language, memory structure, etc.). Machine-oriented languages allow you to use all the capabilities and features of Machine-dependent languages:
· 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 it is necessary to know the command system and the operating features of a given computer;
· 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 written in these languages on other types of computers.
Machine-oriented languages are divided into classes according to the degree of automatic programming.
As I already mentioned, 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. However, some families of computers have a single ML for computers of different power. The command of any of them reports information about the location of the operands and the type of operation being performed.
In new computer modules, there is a tendency to improve internal languages by machine-hardware means to implement more complex commands that are closer in their functional actions to the operators of algorithmic programming languages.
Symbolic Coding Languages(hereinafter referred to as YASK), just like MY, are team units. 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 and greatly facilitates the programmer’s work.
There are also 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 fairly frequently used command sequences that correspond to certain information conversion 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.
A language that is a means for replacing a sequence of characters describing the execution of required computer actions with a more compressed form is called Macro(means of replacement).
Basically, a Macro is designed to shorten the original program entry. 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.
The next type of language is machine independent languages. These are means of describing algorithms for solving problems and information to be processed. They are convenient to use for a wide range of users and do not require them to know the specifics of organizing the functioning of computers and aircraft.
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.
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 problem-oriented languages should provide the programmer with the tools to briefly and clearly formulate the problem and obtain results in the required form.
Universal languages were created for a wide range of tasks: commercial, scientific, modeling, etc. The first universal language was developed by IBM. It allows you to work with characters, digits, fixed-point and floating-point numbers. The language takes into account the interrupt capabilities included in many machines and has appropriate operators. The possibility of parallel execution of program sections is provided.
The emergence of new technical capabilities set a task for system programmers - to create software, providing operational interaction between a person and a computer, they were called conversational 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.
Non-procedural languages constitute a group of languages that describe the organization of data processed using fixed algorithms (tabular languages and report generators), and languages for communication with operating systems.
By allowing you to clearly describe both the problem and the actions required 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. Programs written in tabular language conveniently describe complex situations that arise during system analysis.
2.3. Description of some programming languages
Well, let's finally move on directly to programming languages.
COBOL(COBOL - COmmon Business-Oriented Language) is a high-level programming language developed in the late 1950s. association CADASIL to solve commercial and economic problems. It features advanced tools for working with files. Since commands in programs written in this language actively use regular English vocabulary and syntax, COBOL is considered one of the most simple languages programming. Currently used to solve economic, information and other problems.
Lisp(LISP - LISt Processing) is an algorithmic language developed in 1960. J. McCarthy and designed to manipulate lists of data elements. It is used primarily in US university laboratories to solve problems related to artificial intelligence. In Europe, they prefer to use Prolog for work on artificial intelligence.
LOGO(LOGO) is a high-level programming language developed at the Massachusetts Institute of Technology around 1970 for the purpose of teaching mathematical concepts. It is also used in schools and by PC users when writing programs for creating drawings on a monitor screen and controlling a pen plotter.
Pascal(PASCAL is an acronym from French - Program Applique a la Selection et la Compilation Automatique de la Litterature) is a high-level procedural-oriented programming language developed in the late 1960s. Niklaus Wirth initially to teach programming at universities. Named after the 17th century French mathematician. Blaise Pascal. In its initial version, Pascal had rather limited capabilities, since it was intended for educational purposes, but subsequent improvements made it possible to make it a good universal language, widely used, including for writing large and complex programs. There are a number of programming systems in this language for different types COMPUTER. For IBM PC the most popular system is Turbo Pascal Borland (USA).
Prologue(PROLOG - PROgramming in LOGic) is a high-level declarative programming language designed for the development of artificial intelligence systems and programs. Belongs to the category of fifth generation languages. It was developed in 1971 at the University of Marseille (France), and is one of the widely used and constantly developing languages.
Si(C) is a multi-purpose high-level programming language developed by Denis Ritchie in the early 1970s. based on the BCPL language. Used on minicomputers and PCs. It is the base language of the Unix operating system, but is also used outside this system to write fast and efficient software products, including operating systems. There are a number of popular versions of the C language available for the IBM PC, including Turbo C (Borland), Microsoft C and Quick C (Microsoft), and Zortech C (Symantec). Many of these versions also provide work with C and C++.
C++(C++) is a high-level programming language created by Bjarne Stroustrup based on the C language. It is an extended version that implements the principles of object-oriented programming. Used to create complex programs. For the IBM PC, the most popular is the Turbo C++ system from Borland (USA).
Fortran(FORTRAN - FORmula TRANslation) is a high-level programming language developed by IBM in 1956 to describe algorithms for solving computational problems. Belongs to the category of procedurally oriented languages. The most common versions of this language are Fortran IV, Fortran 77 and Fortran 90. It is used on all classes of computers.
In the mid-60s (1963) the language was created at Dartmouth College (USA) BASIC(English BASIC from Beginner’s Allpurpose Instruction Code - all-purpose symbolic instruction code for beginners). Over time, as other dialects began to appear, this "original" dialect became known as Dartmouth BASIC. The language was based partly on Fortran II and partly on Algol-60, with additions making it suitable for time-sharing and, later, text processing and matrix arithmetic. BASIC was designed so that students could write programs using terminals with time sharing. It was created as a solution to problems associated with the complexity of older languages. It was intended for more “simple” users, not so much interested in the speed of programs, but simply in the ability to use the computer to solve their problems. Due to the simplicity of the BASIC language, many novice programmers begin their programming journey with it.
Refal, developed here in Russia (USSR), in 1966. This language is simple and convenient for describing manipulations of arbitrary text objects.
Refal is widely used in the development of translators from algorithmic languages, both universal and problem-oriented, and autocodes. In addition to being used in translation problems, Refal has such important areas of application as machine execution of cumbersome analytical calculations in theoretical physics and applied mathematics; designing “smart” information systems that perform non-trivial logical processing of information; machine proof of theorems; modeling goal-directed behavior; development of interactive training systems; research in the field of artificial intelligence, etc. Due to the fact that in Refal the programmer himself determines the structure of the information being processed, the effectiveness of the program significantly depends on the successful or unsuccessful choice of this structure. The correct use of certain variables can also significantly increase the efficiency of the Refal program.
AppleScript- machine-dependent (oriented to work with PCs such as Macintosh from Apple), close to natural English language programming designed to automate repetitive tasks, primarily related to processes computer graphics(including processing scanning results, image input, color separation, cataloging, transferring printed documents to World Wide Web, etc.).
Clipper- a high-level language and programming system designed for developing programs for PCs, mainly systems for managing large amounts of data. The owner and developer of the Clipper language and system is Nantucket (USA). The first Clipper software products are ClipperWinter "84 (May 1985), McMax (version for the Macintosh PC - 1986). They implement the concept of open architecture and are a language, compiler and system for developing programs for PCs, including a set of commands and functions , preprocessor, linker, set of utilities.
dBASE- a high-level programming language designed for creating packages application programs related to the manipulation of large amounts of data (Xbase). The first version of the dBASE II language was released in the early 1980s, and dBASE 5.0 for Windows was released in August 1994.
HTML , html(HyperText Markup Language) is a hypertext markup language developed at the CERN research center in 1992. It is derived from SGML. HTML sets the format for hypermedia documents on the WWW. HTML documents are ASCII files that can be viewed and edited in any text editor. The difference from a regular text file is the presence in HTML documents special teams- tags that indicate document formatting rules.
PostScript- an object-oriented language developed by Adobe Systems (USA). It is one of the main standards for printing and transmitting documents, works with images, including fonts. It is a set of commands for forming complex geometric shapes from a collection of simple blanks (circles, rectangles, straight and curved lines, etc.). Fonts and drawings made using vector graphics PostScript language, can be scaled without losing the quality of their printing or display on the monitor screen. Used for control laser printers when printing documents and other data output devices.
SQL(Structured Query Language) - a structured query language - is designed to provide access to relational databases. Created by IBM Corporation. Most file servers and many database management systems use SQL as their standard means accessing data from client applications.
VRML(Virtual Reality Modeling Language) - a virtual reality modeling language (slang term - vermeil) - is intended to unify and simplify the presentation of three-dimensional and moving graphics, including the synchronization of image and sound. VRML is considered by developers as a language, although related, but alternative to HTML and interacting with it. The idea of language was first proposed by Mark Pesce in 1993.
3. Programming language Java
3.1. Language overview Java
This part of the work is devoted to one of the most promising programming languages today - the Java language. The technology called Java can be called, without exaggeration, revolutionary in the software development industry. What is the promise and revolutionary nature of this technology?
Today, creating software is an extremely difficult task. Difficulties are associated with the variety of machine architectures, operating systems, graphical shells, etc. The rapid growth of Internet-related technologies further complicates this task. TO Internet networks computers of various types are connected - IBM PC, Macintosh, Sun workstations and others. All these systems form single network, which must work as one whole, while ensuring a high level of information security.
Thus, modern applications must be secure, high-performance, run in a distributed environment, and be architecture-neutral. Sun Microsystems' Java development system meets all of these requirements. Java is an object-oriented language, convenient and reliable in use due to its advantages such as multitasking, support for Internet protocols and multi-platform.
The Java language comes with a fairly large class library. Java class libraries greatly simplify application development by providing powerful tools for solving common problems.
Programs developed in the Java programming language can be divided according to their purpose and functionality into two large groups:
· Standalone programs (let's call them Java applications) running independently on the local computer
Applets running on the Internet
Currently java work Supported by all major computer platforms. A standalone application designed for battery life, is compiled and executed on a local machine running the Java runtime system.
Applets, which give the language its popularity, are a type of Java application that is interpreted Virtual Machine Java, built into almost all modern browsers.
Each applet is a small program that is dynamically downloaded over the network from a Web server when opened in a browser. HTML pages, which contains a link to the applet - just like the picture, sound file or an element of animation. main feature applets is that they are real programs, and not just another file format for storing cartoons or any other information. The applet does not just play the same script, but reacts to user actions and can dynamically change its behavior. With applets you can make pages Web server dynamic and interactive. Applets allow you to perform complex local processing of data received from a Web server or entered by the user using the keyboard. For security reasons, applets (unlike regular Java applications) do not have any access to the file system local computer. They can receive all data for processing only from the Web server.
3.2. Process of creating a Java program
Source file on Java language is a text file containing one or more class descriptions. The Java translator assumes that program source codes are stored in files with java extensions. The bytecode obtained during the translation process for each class is written in a separate output file, with a name that matches the class name and a class extension. It is the class files containing bytecode that are interpreted by the Java runtime system into machine code for a specific system. First of all, the Java bytecode is loaded into the runtime system by the class loader. The class loader is responsible for ensuring that all the classes needed to run the application are loaded. The bytecode is then checked by a bytecode verifier to ensure that there are no operations that could violate the security of the system or cause an emergency in it. It is important to note that the class loader and bytecode verifier do not make any assumptions about the origin of the codes: they are obtained from the local file system or from another continent. The verifier ensures that any code that passes the test can be used by the interpreter without the risk of damaging it.
After such a security check, the bytecode is interpreted into machine code and executed by the interpreter. Moreover, classes received locally (deserving unconditional trust) and classes sent over the network from the rest of the world (and potentially hostile) are located in different namespaces. When resolving a reference to a class, it is looked up first in the local space. This prevents "external" code from replacing one of the base classes in the system. Also, during the interpretation process, the necessary libraries (files with the jar extension) are connected. The entire described process of executing Java programs is depicted in Fig. 1.
Rice. 1. Process of creating a Java application
As mentioned above, Java technology implies easy portability of software products from one platform to another. No programming language provides this degree of ease of portability.
If a Java application (or applet) needs to run on multiple platforms, there is no need to compile its sources multiple times. You can compile and debug a Java application on one, most convenient platform. The result will be bytecode suitable for any platform that has a Java virtual processor (Fig. 2).
Rice. 2. Prepare a Java application to run on different platforms
3.3. Virtues of language Java
The language had to embody the following qualities: simplicity and power, security, object orientation, reliability, interactivity, architectural independence, interpretability, high performance and ease of learning. Even if you never write a single line in Java, knowing about its capabilities is very useful, since it is the properties of the language listed above that determine its choice.
Safety. In popular literature these days, especially when it comes to the Internet, discussion of security issues has become a fashionable topic. People believe that using the Internet for business is equivalent to writing your credit card number on the wall of a telephone booth. One of the key design principles of the Java language was to provide security against unauthorized access. Java programs cannot call global functions or access arbitrary system resources, giving Java a level of security not available in other languages.
Reliability. Java limits you in a few key areas and thus helps you catch errors early in program development. At the same time, it does not contain many sources of errors inherent in other programming languages. In traditional programming environments, memory allocation is a rather tedious task - the programmer has to keep track of all the memory used in the program, remembering to free it as it is no longer needed. Often programmers forget to free memory they have acquired, or, worse, free memory that is still in use by some part of the program. Exceptions in traditional programming environments often occur in cases such as division by zero or attempting to open a non-existent file, and must be handled using clunky and unreadable constructs. Java effectively alleviates both of these problems by using a garbage collector to free unallocated memory and built-in object-oriented facilities to handle exceptions.
A special garbage collection process is one of the most interesting features Java programming language and Java application runtime designed to remove unnecessary objects from memory. This system relieves the programmer of the need to closely monitor memory usage by explicitly freeing areas that are no longer needed.
Interactivity. Java was created as a tool that would satisfy the urgent need for creating interactive network programs. Java implements several interesting solutions, allowing you to write code that executes a lot of things at the same time various functions and does not forget to keep track of what is going to happen and when. Java uses the most elegant method ever invented to solve the problem of process synchronization, allowing you to design beautiful interactive systems. Java's easy-to-use, elegant subprocesses allow you to implement specific behavior in your program without the hassle of building in global event looping.
Independence from computer architecture. The issue of longevity and portability of code is more important than the religious wars between PCs and Macintoshes. The creators of Java imposed several strict requirements on the language and on the runtime environment that, in practice, not in words, allow, once written, a program to always run anywhere and at any time.
Interpretation plus high performance. Java's extraordinary ability to run its code on any of the supported platforms is achieved by translating its programs into an intermediate representation called bytecode, which in turn can be interpreted by any system that has a Java runtime environment. Most early systems that attempted to be platform independent suffered from a huge performance penalty (Basic, Perl). Even though Java uses an interpreter, the bytecode is easily translated directly into native machine codes (Just In Time compilers) on the fly. This achieves very high performance (Symantec JIT is built into Netscape Navigator).
Easy to learn. The Java language, although more complex than shell languages, is still immeasurably easier to learn than other programming languages, such as C++. Java differs from C++ in its lightweight understanding of Java syntax.
Conclusion
Invention of a programming language top level allowed us to communicate with the machine, it seems, even to understand it. Indeed, if we pay attention to the rate of growth and development latest technologies in the field of programming, we can assume that in the near future, human knowledge in this area will help produce languages that can receive, process and transmit information in the form of thoughts, words, sounds or gestures. Such languages can rightfully bear the name of “highest”. Perhaps the concept of solving this issue is simple, and the near future of this project is not far off, and at this moment, somewhere, a young, unrecognized specialist is hunched over and developing the latest system artificial intelligence, which will finally allow a person, with the help of their machine languages, to conduct a dialogue with a computer in YOU.
Perhaps the Java programming language, a very elegant and beautiful language, will become the basis for the programming of the future. After all, Java is equipped with a rich library of classes and at the same time is quite easy to learn. It should also be noted that the application development cycle is shortened due to the fact that the system is built on the basis of an interpreter. The application is automatically portable across multiple platforms and operating systems. Due to the built-in garbage collection system, the programmer is freed from the need for explicit memory management. The application is easy to maintain and modify, because modules can be downloaded from the network. Built-in security system prevents illegal access and viruses. All these qualities, I believe, will allow Java to take a leading place among programming languages.
Concluding my work on such an optimistic note, I would like to say that the progress of science and technology, the highly computerized future of humanity, as the only creature on the planet, albeit not using one specific spoken language, but capable of so quickly progressing and developing its intellect, will allow to soon move from a multilingual system to universal understanding.
List of sources used
1. Bishop D. Effective work: Java 2. - St. Petersburg: Peter; K.: BHV Publishing Group, 2002. – 592s.
2. Vaulin A.S. “Programming languages”: book 5, 1993 – 232 p.
3. Weber D. Java technology in the original: trans. from English - St. Petersburg: BHV - Petersburg, 2001 – 1104 p.
4. Zaretskaya I.T., Kolodyazhny B.G., Gurzhiy A.N., Sokolov A.Yu. Computer science 10-11 grade. - K.: “Forum”, 2001 – 494 p.
5. Lyakhovich V.F. Fundamentals of computer science. -Rostov-on-Don: Phoenix, 1996. – 699s.
6. Ushkova V. “New programming languages and trends in their development”, 1982 – 335 p.
7. Computer technology and programming / Ed. A.V.Petrova -M.: Higher. school, 1990 – 479s.
8. Computer Science: Basic course/ S.V. Simonovich et al. - St. Petersburg: Peter, 1999. – 640s.
9. Website materials: www.sun.ru
I don’t know how things are in education now, but 10-15 years ago, neither at school nor at university, no one seriously explained that programming has its own types, each of which requires a special type of thinking. Not that this will cripple anyone’s destinies, but the study of software disciplines could go much faster if, at the stage of laying the foundation, we presented a variety of languages and approaches, and did not zombie-teach C++ in its console manifestations.
Many people, faced with the need to write functional code, often regret that the procedural way of thinking is so deeply ingrained in the brain that it is not easy to change from it. Therefore, it is better to start your path to becoming a programmer not by choosing a language, but by choosing a type of programming.
Types of programming
Let’s agree right away: there will be six types. This is a fairly detailed division. Usually 3-4 are allocated, but since we are faced with the task of choosing a path for beginners, it is completely justified.
Procedural programming is also imperative.
It poses the task of creating code in a language that the machine used can understand. The most famous case is the Turing machine; among the well-known programming languages - C/C++, Ada, Pascal, Go. The tasks here are solved systematically: first, an object is declared, then it is defined, and then an action is performed on it:
var
S: String;
S:= ‘Hello!’;
Declarative programming.
In the procedural case, the language optimization vector is directed from the machine level to the user language by using the basic principles of OOP, classes, methods, etc. Here, the task itself is at the forefront, and the method of its execution is secondary. A striking example is the HTML markup language. If you want to place a button, you don't formally need to create an object and assign attributes to it:
Functional programming.
As you know from the mathematics course, the result of executing any function can be presented in the form of tabular data, the only question is the sampling frequency and the range of values. That is, no matter how many times the function is executed, no matter what its place in the problem, the result for the same values will remain the same. In imperative programming, this is not always done, because the values of variables can change during the course of the program, which will make the result dependent on specific conditions.
Functional programming does not have this drawback: here you operate with functions - initial, incremental and resultant - but not with specific values. Popular representatives include Lisp, Clojure, Haskell. Functional programming is considered complex and redundant for most applications. Hence the low demand for specialists, but this also results in high salaries and really interesting work.
Logic programming.
As the name suggests, it operates on simple mathematical logic. Prominent representatives are Planner and Prolog. A fairly limited set of actions can be really useful for creating the simplest artificial intelligence or stretching the brain, but in real life, logic programming is rarely used on its own.
Dynamic programming.
The case when, to solve a complex complex task it is necessary to break it down into several simpler ones, minimizing the number of execution cycles. Ideally, each simple task should be performed once, but in practice this is quite rare. Dynamic programming- rather a concept applicable to all languages, so this direction has no representatives. But it will require a special way of thinking from you in the same way.
Graphical programming is also visual.
It invites the developer to work with graphic images, not text. This can be expressed in different ways - there are special languages, like Scratch or BluePrint, there are languages of diagrams or diagrams (LD or FBD), there are simply sections of programming related to interaction with forms and graphics. In the latter case, it can be any language; visualization is carried out by development tools (Borland Delphi/C++, Visual Studio, Adobe Dreamweaver etc.). Such graphical programming in its pure form is extremely rare; without understanding the language and structure of the code, it is impossible to create something serious.
Rest
Programming is divided into many types, and beginners don’t even know about some of them: synchronous/asynchronous/event-based, sequential/parallel, different in the tasks they solve and the involvement of AI and statistics.
Choosing a starting programming paradigm does not mean choosing only one path. On the contrary, without being tied to specific languages, professions and software environments, starting with “your” way of thinking, you will initially set yourself up for a correct understanding of the essence. A successful, happy and rich IT specialist is not the one who gets into the right stream, but the one for whom any stream is an opportunity to realize his potential.
Loading...
