The software developer is an IT specialist who creates all kinds of programs for a computer.
He can work on corporate software, video game, a PC program and many others, using various software development tools.
Such a specialist should have the following skills:
knowledge of at least one programming language;
Understanding the principles of OOP, algorithm and data structures;
the ability to work with OS, network protocols and methods of exchange of information on the network;
Possession of codes testing and debugging tools.
Frondender needs to be able to:
create a dynamic, interactive interface on the layout;
work with details and know the nuances of the task in order to ensure the convenience of operating the product;
Use the principles of adaptive layout. This allows you to create a multi -platform product.
Bacender performs the following tasks:
develops a betting program in one of the languages;
interacts with the file system, search and sorting algorithms;
performs integration with databases, forms requests;
Participates in ensuring network safety and organizing software protection from various viruses and attacks.
Full Stack is a wide profile programmer. It can perform all tasks related to the creation of software, including the formation of the client and server part of the product. He needs to have the following skills:
knowledge of several programming languages, common libraries and frameworks;
Work skills in the GIT version management system, application for assembly and deployment of the Docker or Kubernetes application;
Understanding the design templates and the possession of flexible methodologies (say, agile).
It should be noted that the software development system consists of many processes, during which it is often necessary to use various approaches, technology and methodology. Each development option has its pros and cons, as well as the most suitable area of application.
Polymorphism: essence, problems of application
What it is? In object-oriented programming, polymorphism is inheritance and its basic principle. Everything sounds complicated, but in fact it should not cause difficulties. The word “polymorphism” translates as “many forms.” Applying it to programming, we can say that any code can have many different forms.
Why do you need it? This principle is needed to facilitate the work of the programmer. For example, he does not have to write a new code each time, but it is enough to copy the properties of one to create another similar. For example: on the site there are articles, ads and news. The codes for their creation are similar, but not identical. Their basis unites – content, and what it is, these are already doped codes. We talked in more detail about polymorphism below in the article.
What is polymorphism in OOP
Object-oriented programming often requires the creation of new classes that can expand the structure and behavior of an existing class. This is done using the inheritance mechanism. When a new class appears, which expands the old one, it is indicated in its definition that it inherits from the old.
The new contains the same fields and classes, but only new (previously not used) fields and methods are indicated in its body. The ability to use the same code repeatedly to create new ones makes the programming process more convenient, fast and simple.
The inheritance mechanism involves the use of the following terminology. When class D inherits from class B, the latter is basic for D, and D is derived from B. This mechanism in object-oriented programming does not only make it possible to take fragments of programs on the basis of the production of new ones, but also allows you to perform the same actions over objects of different classes using the same expressions. This is “polymorphism.”
In order to understand the principle of polymorphism, it is necessary to delve into the theory.
There are abstract classes – these are those that contain at least one abstract method (that is, requiring redundancy).
It is impossible to create an abstract class object.
The derivative class has the properties and methods inherited from the basic, as well as new ones.
The method, which in the derivative of the class is redesigned, has the name “virtual”. In the basic abstract class, there is no information about it.
Abstracting is to determine the method in the place where there are the most comprehensive data on how it should work.
To define polymorphism, it is worth considering an example of its application in practice. There is an information portal on which news, announcements and various articles are placed. Technically, they have general characteristics like headings and text. News and ads have a date of publication. However, there are differences: the articles are written by specific authors, the news is taken from certain sources, the ads lose their relevance after some time.
You can write three separate classes for each kind of publication and use the one that is needed at the moment. But there is another option – to make one class with the properties of all types of publications, while only the necessary will be used. However, it is obvious that for different types, methods similar in terms of action should function differently.
Writing of the same methods for different types of publications (Get_news, Get_announcements, Get_Articles) cannot be called the right one from the point of view of programming. It is here that a phenomenon as polymorphism is used.
The abstract class is a chain class. It implements functionality only at the level at which it is known at the moment. The derivatives of the classes complement it.
The benefits of polymorphism in programming
Polymorphism is the largest bonus from the use of hierarchical data types. There is an opportunity to create a simpler and more generalized code based on basic types, and thanks to this, increase the level of abstraction and reduce the complexity of the program.
However, there is no clarity to which particular type the object will ultimately relate and how the called methods should be implemented. The compiler will not be able to connect the method of the method with its implementation.
In this case, the binding is understood to compare the comparison of the name of the method in the code with the specific implementation of this method (address of the method of method in memory). Binding at the compilation stage is called static, at the stage of execution – dynamic. Accordingly, polymorphism is possible only with dynamic binding.