What is this article about

Attempting to explain why the study of modern technologies is difficult, how to find the easiest way to master them and become an expert.

Who is this article for?

In order not to disappoint the reader, you must immediately decide for whom this article is intended. First of all, this article may be useful for programmers who want to independently master the creation of software. It may be useful to teachers of programming. At the same time, she describes a point of view that may differ from the vision of professionals who have passed their way and have their own well-established understanding of things.
')
This article is also more research than strong recommendations. In view of this, it may require the reader to attempt to consider issues from the point of view of the author. Also having a direct relationship to learning this article may seem useless and boring when viewed from a production point of view.

Foreword

Although information technologies are very developed these days, their mastering and becoming a qualified professional continues to be difficult. The author, being an instructor coach, made several attempts to find his students the most convenient way to master programming and related topics. This article is an attempt to build a simple structured picture of this issue.

The author tried to write the article as simply as possible, to indicate the key principles of his vision and to offer a useful self-development strategy to specialists at all levels.

The author began using the C # language since its inception. Until this time, the author has gained rich experience in working with a variety of IT technologies - hardware, internal OS features, the language Assembler, C ++, COM, WinApi, networks, multithreading, etc ... These skills have essentially helped to master C #, as well as their new versions. But for beginners, training also requires them to learn a lot of new technologies from various unfamiliar areas, which makes studying a long and difficult process.

Greatest difficulty

The greatest difficulty arising from the study of something is the huge number of different technologies, as well as the industrial sectors where these technologies can be applied. Also, this number is constantly increasing (see the so-called "technological singularity").

Orientation in such a complex environment becomes very difficult. Simple rules, explanation and strategy would be very helpful.

Man, Tool, Problem

To understand many important processes and elements of the training system, the Human-Tool-Problem link can be used.

For the convenience of analyzing the problem, we take the following assumptions:

• Man - the main character. The person uses the Tool to solve the Problem. A person must have the necessary skills to use the Tool;
• The problem is the main task for Man - it requires a solution;
• A tool is a tool to solve a Problem. Each tool is designed to solve only specific problems. That is, there is no Instrument capable of solving all problems. A programming language is also a tool designed to solve the problems of creating software;
• During the solution of the Problem, the Person does not interact with it directly, but through the Tool (It is understood that the Tools make the interaction of the Person with the Problem easier than the direct interaction of Person-Problem. If such a tool does not exist, it should be created).

Complexity of Problem and Tool

Different problems have different difficulty solving. Accounting for the family budget is a much simpler task than managing the delivery of goods around the city.

To simplify the explanation, we can consider the complexity of the problem only as the complexity of its solution. The complexity of the tool, in turn, can be considered as the complexity of its use by humans. The simpler the tool, the easier it is for a person to use it.

Various tools can be used to solve one problem. For ease of use Tools can be divided into groups:

• The most useful ones are easy-to-use solving difficult problems;
• Medium - difficult to use solving difficult problems;
• Useless - difficult to use solving simple problems.

Difficulty of Use

For a person, ease of use of the tool is most important. The complexity of the tool can lead to delays, poor quality results, and the impossibility of solving the problem. It goes without saying that the lack of a tool can be the cause of the complete impossibility of solving a problem (We don’t consider a solution without a tool - this is the rank of the simplest problems). Thus, when creating a tool, the main criterion is ease of use.

The complexity of something for a person can be classified as follows:

• Too many simple elements. These simple elements are very simple and require a complex composition to solve the problem. Low-level languages ​​such as Assembler or MSIL are examples of languages ​​with a similar type of complexity. This level of complexity is most convenient to implement hardware, since the equipment is capable of performing a huge number of relatively simple actions;
• A small number of elements with a small number of properties. This is the most convenient level of complexity for a person. The basic elements of high-level languages ​​can be attributed to this level;
• Items with too many properties. Tools of this level of complexity are designed to solve a narrow range of tasks and require customization if the task is slightly different. Software packages and libraries can be assigned to this level of complexity.

Low, High, and Super High

The evolution of programming languages ​​has led to an increase in the level of abstraction of programming languages ​​from the hardware platform:

1. Low-level languages ​​are convenient for hardware implementation, but difficult for a person due to the large number of commands that perform the simplest operations;
2. High-level languages ​​are convenient for human understanding, which allows you to develop programs faster. But these languages ​​are difficult to implement for hardware implementation, which generally leads to slower code and greater resource consumption;
3. Very high-level programming languages ​​(VHLL) are programming languages ​​with a very high level of abstraction. Unlike high-level programming languages, where the “how to do” principle is described, in the super-high-level programming languages ​​only the principle “what needs to be done” is described.

With the normal development of programming languages, their level corresponds to the level of abstraction from the low hardware level. With increasing abstraction complexity of use should not increase. However, in reality, it can be difficult to understand. Increasing the level of abstraction is almost always associated with the creation of large structures that hide the complexity inside and give the simplicity of their use from the outside.

But for correct use in order to avoid negative side effects, the developer needs to know the internal structure of the structures. So when using sockets in a network application, you need to know the appropriate network protocols and how networks work. Without their understanding, it is unlikely to write a quality product in reality. That is, increasing the level of abstraction simply hides the complexity inside, but does not eliminate it.

The evolution of programming languages ​​shows their constant improvement, but over a long period of development has not simplified their understanding. It should also be mentioned here that the range of problems solved by IT has significantly expanded - therefore, they remain complex.

This evolution is not an easy process. However, some features may help to understand this process:

• The evolution of hardware platforms provides growth opportunities for the entire IT sector;
• The growing capacity of the IT sector allows these technologies to be used to solve increasingly complex and complex problems;
• Difficult problems can be solved only by tools that have internal complexity but are easy to use. (If the tool is difficult to use - it is not necessary);
• Internally complex tools are more difficult to create (than internally simple ones);
• The complexity of programming languages ​​reflects the complexity of the tasks.

The complexity of programming languages

The complexity of modern programming languages ​​is the result of the following main factors:

• Multithreading There is a constant increase in the parallelism of command execution, supported by a growing number of devices. This requires additional forces to synchronize the flow and use of resources;
• Complex components in standard libraries. There is a constant growth of components that are embedded in standard libraries and have a large number of properties. It is necessary to know how these components are arranged internally in order to avoid negative side effects;
• Multi-platform support. There is a steady increase in the range of devices and platforms that require ensuring the correct behavior of the program on as many devices as possible. This is particularly evident for mobile applications;
• Evolution. The development of other languages, the development of equipment and even commerce (a new version is a new product for sale in the market) influence a certain programming language.

Upper-Level Languages

The described evolution of programming languages ​​has led to the emergence of large components with a large number of properties. The development of high-level languages ​​is based on low-level languages ​​(for example, compilation from high-level to low levels is used) by integrating small components (commands) into larger structures. Among other things, the described processes have inertia, which ultimately translates the programming language from a high level further to the so-called Super-high.

As noted, the growth of the level of abstraction leads to the appearance of large structures (elements of the language, functions, libraries, etc.) that hide the complexity in the internal implementation. However, to create a high-quality product, it is necessary to know the internal implementation, operating time, consumed memory and other properties of the structures used. This leads to a shift in complexity above from being convenient for the developer, as shown in the following figure.

The figure shows the increase in complexity with a large number of simple elements or properties of elements. As you can see tasks with a lot of simple elements, the corresponding low-level languages ​​are convenient for execution by a computer. Tasks with components with multiple properties, in turn, are difficult for a single developer, but can be more easily mastered by a group of developers.

Strategy

First level

The easiest to learn programming level is the level where the number of components and properties of these components is convenient for the developer to understand. Typically, these components reflect simple popular operations — arithmetic operations, processing lines of text, input / output of simple data, and so on. Most books begin the story from this level.

At the initial stage, the most important thing is to understand the question - “what's next?” This is a key tactical question, which allows you to see your development from the current point further. The question “what next?” Can arise in two important cases:

• The developer is faced with the problem of not understanding the topic or method (the problem of getting stuck) or;
• The developer is faced with the problem that there are a large number of topics that can be studied (the problem of choice).

If the developer is stuck on any topic, he should change the direction (vector) of the study - find another way to study this topic or choose another topic to study. If the developer is faced with the problem of choice - he just has to make a choice. That is, you can not stop.

After mastering the entry level, the developer can make a choice of further development in two main areas:

• Low-level programming;
• High-level programming.

Low-level programming

Low-level programming is hardware-friendly programming. Mastering system programming requires learning low-level languages ​​and a platform. The complexity of learning low-level languages, in turn, requires the study of a large number of small simple elements and ways of organizing them in a computer system.

Low-level programming is a specific approach. The developer must decide to follow this direction. This is also a trend rarely chosen by developers.

High-level programming

High-level programming - programming, with the help of which software is usually created that automates major human life processes. It is aimed at solving applied problems, without worrying about the optimization of the equipment operation.

Such systems use high-level languages. The complexity of the study here includes the study of larger (as compared with low-level programming) components of the language and a certain number of their properties. So for example, developers need to know the internal structure and properties of containers (array, stack, hash table, ...) in order to apply them without negative side effects (high memory consumption, slowdown, etc.).

The development of high-level languages ​​leads to an increase in the "size" of the constituent components and, accordingly, the number of their properties (both external and internal). The complexity for the developer increases both in the need to study these components and their properties, and the need to keep track of the constant appearance of new components and versions.

Organization

The problems described above are not intractable. However, if you do not take the right action, you can go to a dead end. Many actions are known and clear. The above description allows you to understand the effectiveness and necessity of these actions:

• Specialization. Since it is impossible to master all the features of a modern programming language, the available components and libraries, specialization allows you to select only one or a few areas (for example, desktop applications, network applications, function libraries, etc.) and work only with them;
• Cooperation. The solution of many tasks by one developer is impossible due to specialization (as it was described it is impossible for one specialist to own a wide range of technologies). Thus, the following necessary action occurs - cooperation with developers owning other technologies.

Recommendations

Summing up we can highlight the following important facts:

• In self-development and professional growth, knowledge of the direction of the desired development is needed - to higher level (more abstract) programming languages ​​or tasks close to the platform / hardware (for example, system programming or real-time systems programming);
• In the case of a stuck in studying a particular topic, you can not stop - you need to either change the way you study this topic or start another topic, putting aside the current until better times;
• If you choose, you also can not stop - you just need to make a choice. And in no case can one be afraid of the fact that so many and all of them cannot be mastered;
• The aim should not be to study a wide range of topics, i.e. need to specialize by choosing a specific series of topics;
• Even in mastering programming, cooperation is very important. Communicate with other developers and participate in forums.

And most importantly, without the love of programming and the desire to work hard, learn programming and become a professional will not succeed. Even in the absence of talent, with perseverance you can achieve some results and find your place in a wide range of IT.