Do not confuse software development and programming.

Every software developer can program, but not every programmer can develop software.

Most can easily learn to cook, but when you need to feed a large number of people, we hire a cook.

Perhaps someone likes to say more than a “developer”, but a software engineer , because an engineer sounds proudly! Or not? Fortunately, this article is not about terms. If you don’t like my term, substitute your: “software author”, “software master” ... and even “application creator”!

Speaking of " software developer ", I mean the person for whom writing quality software is a profession . A person who uses scientific approaches and statistics in his work and considers his occupation to be more than just making money.

To become a developer, knowing how to program is not enough.
')
You can teach anyone to program - it's easy. Almost anyone can write simple programs that work for specific people on specific machines , but no one guarantees that the same programs will work in other conditions.

I like this analogy: for the sake of their own entertainment, everyone can sing in the shower, but you don’t put tracks with recordings of this singing at a party - you turn to works of professional musicians.

Want more analogies? You are welcome:

• At school we were taught mathematics and writing, but this did not make us mathematicians and writers.
  
• Most can easily learn to cook, but when you need to feed a large number of people, we hire a cook.
  
• Nobody calls a neighbor - a master of all trades to build a house from scratch.
  

The main task of this text is to inform that the creation of simple programs is very different from software development .

Transferred to Alconost

Programming in the simplest representation is the transmission of instructions to a computer to perform certain actions with some input data for obtaining some output .

Software development is the design, writing, testing and support of computer programs to solve problems for many users; it is the creation of robust, secure solutions that will stand the test of time and cope with some previously unknown tasks in an area close to the obvious initial problems.

Software developers thoroughly study the tasks being solved, fully understand how their proposed solutions work, how these solutions are limited and how they are characterized in terms of data confidentiality and security.

And if someone does not understand the problem, he should not be allowed to develop a solution for it.

Solution-oriented approach

Software developers do not consider their work simply to write programs - they argue in terms of meeting needs and solving problems . And this is important, because it is not necessary to write a program for any task: in some cases it is enough to use an existing program or combine several programs. And acting on preemption, it is sometimes possible to completely get rid of the need to solve this problem: the development of good programs often involves planning, which allows you to prevent the appearance of some problems and related problems in the future.

"Clever solve problems - geniuses prevent them."
- Albert Einstein

For complex tasks, you have to write several programs. In some cases, programs that work in parallel are needed, in others, they are launched in series. Sometimes to solve a problem it is enough to train users.

Before writing code, the developer will ask the following questions:

• What tasks am I trying to solve?
  
• How can I solve the problem without programming?
  
• What can be done to write the code to solve the problem was easier?
  

Quality code

In quality programs, the code is clear and easy to read, they can be easily expanded, they interact perfectly with other software, and their support does not turn into a nightmare. The quality of the code should not fall victim to compromises; the use of quick, but careless decisions due to a deadline, excessive excitement, agitation, irritability, etc., is unacceptable.

One of the most important aspects of software development is designing from scratch a product that is ready for expansion. Modification of applications after their release - a fact that you need to accept. Users will need more and more functionality, they will want to use the application was even easier.

The application component is usually not very useful in itself. The benefit of the software begins to bring in when several components interact with each other, exchange data and work together on the task of presenting data and interfaces to users.
And with this in mind, you need to develop programs. What messages does the software take? What events are tracking? What messages does it give? How is authentication and authorization during data transfer?

Another important aspect of writing good programs is understandable code, and not at all the number of tests or the number in the code coverage report. Everything is simple here. Think: can others read the code? Or - which is even better - can you, having written the code today, understand it after a few weeks?

"In computer technology, there are only two complex tasks: invalidating the cache and inventing names."
- Phil Carlton

Code readability is much more important than it might seem. Unfortunately, there are no convenient indicators for evaluating this characteristic. It will be useful to remember the proven programming techniques and patterns, but often this is not enough. A good developer with experience just develops intuition, which tells how readable the code is. Here is a good comparison: to write concise text, it is not enough to have a large vocabulary.

"I did not have time to write a letter shorter."
- Blaise Pascal

With any program at some point, something will definitely go wrong. The main feature of good software is the ability to easily fix a program that has already been released. If the program generates an error during operation, there must be a clear message about it, which will be somewhere centrally recorded - so that errors can be tracked. When reporting a new error, the person responsible for fixing it should be able to debug, connect to the system at any time and get information about the execution context, and also check the expected behavior of any component of the system.

Work environment and testing

When a developer writes a program, he checks that it works in many different environments, on machines with different resources and in different time zones. The software should work on screens of various sizes and orientations, in conditions of limited memory and low computational power.

For example, if the software is written for a web browser, it should work on all major browsers. When creating classic software, it should in most cases work on Mac and Windows platforms. If the application being created depends on receiving data, it should continue to work even if the data connection is slow or even for some time completely absent.

To write a software component, developers are trying to think through all possible scenarios that you can imagine, and plan to check them. They start with what is called the default script (or “happy road” - from the English “happy path”), in which nothing unexpected happens, and all possible problems along this path — what is important — are documented and a test is planned for each. Some developers start by writing “test cases” that mimic such scenarios. Then they write the functional code that passes these test cases.

Developers need to understand the requirements for software, but they are often ambiguous and incomplete. The developer’s skill is not shown in how he writes a solution, but rather in what solution he deems necessary.

Cost and effectiveness

In most cases, the developer can solve the problem quickly. If it seems to you that it is expensive to hire experienced programmers, think about it: the more experience a programmer has, the faster he will create a functional, accurate, reliable solution that will be easy to maintain. And this is a lower cost in the long term.

In addition, the “cost of work” of the program should also be taken into account: any software consumes computer resources, but they are not free. The developer will write an effective program that will not use PC resources unnecessarily. To do this, it can apply, for example, caching frequently used data - and this is just one of probably thousands of tools and methods that help improve the efficiency and speed of the program.

Perhaps a novice programmer will give a cheap solution, but working with this solution can cost you and your customers a lot more than if you immediately hired an experienced developer who primarily seeks to find an effective solution.

The convenience of use

Good software is developed taking into account the interaction of a computer with a user (UX), and this is a rather extensive topic on which a lot of research has been done and a lot of results have been obtained. The more conclusions from these studies are taken into account, the better the software will be in use.

Let me give you a couple of examples so that you can feel why this is important:

• Well-designed software in user input forms will not case sensitive characters in the email field and will remove leading and trailing spaces. No need to complicate the lives of users due to the fact that they have enabled CAPSLOCK: the email address is not case sensitive. If the program accepts new email addresses, check them in advance and understand the language to inform the user that he may have entered the wrong address. This means banal errors - for example, the absence of the symbol @, - and not so obvious: for example, the erroneous spelling of a popular domain: “gmail.ocm”.
  
• If the user needs to be redirected somewhere, a good program will remember the source point and, after performing the necessary actions, will return the user there. It will also remember already known data and interactions that need to be associated with the subsequent steps of the user. Suppose, for example, that you on Expedia searched for flights as a guest without logging in - and then decided to create an account. All previous search queries in the new account will be saved, and you can use them from other machines.
  
• Good software is developed taking into account the real scenarios of work in it users. You can not just add some functions - you need to put yourself in the user's place. The other day I booked a flight with United Airlines and forgot to add my frequent flyer number. After receiving the confirmation, I went to the United Airlines website to add this number to the flight, and it took me ten minutes. There was no obvious way to add this number, so I had to climb on all the links that I thought could lead to the necessary functionality. Finally, I found the right page: it turned out that the last time I did not notice the right field, because it was deeply buried in great shape. As a result, I needed to edit the passenger data, scroll 20 input fields on this form, select the desired type of number and be sure to enter a phone number - otherwise the form could not be sent. This is an example of a program that could be developed by a person who did not try to think from the user's point of view.
  

Reliability, safety and security

Perhaps the most important aspect that distinguishes professional developers from amateur programmers is that professionals know that they are responsible for creating secure, secure solutions.

The software component must be resistant to “bad” data, incorrect states and incorrect interaction. To achieve such sustainability is VERY difficult - that is why we constantly read about how someone died due to a software error.

Users will enter "bad" and incorrect data in the software. Someone will do it intentionally - in order to hack the software and get to the resources that this software represents. The employee, allegedly responsible for the security breach of the American credit bureau Equifax, which was used by the attackers, was accused of not having done his job: he had to ensure resistance to “bad” and malicious data in all software openly published on behalf of the company .

The task of ensuring security is associated not only with “bad” and malicious data, but also with normal ones. For example, if a user forgot a password, how many times can he try to enter it? Will it be blocked after the input attempts have been exhausted? What if someone deliberately tries to block a user? Should users be able to send a password over an unencrypted connection? What if someone tries to log in from an unusual place? What to do if there is a suspicion that the login is automatic?

How to protect your users from cross-site scripts and cross-site request forgery, middleware attackers and simple social phishing? How to develop a backup operation strategy in case of a DDoS attack on servers? These issues are only a small fraction of the many questions that need to be considered when designing.

Protected programs store confidential information not in the form of plain text, but as one-sidedly encrypted data with hard-to-break algorithms. This is backup protection in case of hacking software and unauthorized access to data: hackers will get encrypted data, which in most cases will be useless.

An application can go into an error state, and it will need to be fixed: even in the best programs, unexpected problems arise. If you do not take this into account when planning, you are not a professional developer, but simply an encoder with unsafe programs.

Software defects are difficult to identify. Our mind is limited in its ability to predict and prevent known defects. Therefore, software developers appreciate good tools that help write the correct code and create secure software.

Tools used

Obviously, we need more tools and we need better tools. In software development, tools are important, but they are often underestimated.

Imagine for a moment that we would still need to use FTP for deployment! Imagine network debugging and performance issues without browser development tools! Imagine how the effectiveness of writing JavaScript code will fall if you do not use ESLint and Prettier!

If for some reason you are forced to leave only one plugin for the code editor in JavaScript development, choose ESLint.

A great addition would be any tool that shortens the feedback loop when writing code. The thought of Bret Victor about inventing instant visual representations of what we create opened my eyes. Using and improving tools is one way to get closer to this bright future. If you have not seen Bret's performance, be sure to watch it.

When I find a great tool, I only regret not using it before. The better the tool, the better programs are written with its help. Search, use and appreciate them, and if you can - and improve.

The choice of language is important. Type safety is important. The best thing that happened with JavaScript is TypeScript (and Flow). Static code analysis is more important than you think. If you do not use it, you are, in essence, vulnerable to possible unknown problems in the future. Do not write code without a static type control system. If there is no static type control in the selected language, you need to either change the language or find a transcompiler for it: today they are already smart enough to work on comments in the code, and it seems to me that for languages ​​that do not support static type checking, transcompilers will soon become standard tool.

Becoming a software developer

It’s impossible to learn how to develop software in a couple of months, half a year or even a year. The programming courses of you will not make a developer. I started to study 20 years ago - and I continue to study today. With enough confidence, I was able to call myself an experienced programmer only after ten years of training, during which I had to design, build and provide support for applications used by thousands of users.

Software development is not for everyone, but everyone must learn to solve their own problems with the help of computers. If you can learn how to write simple programs, do it. If you can learn how to use uncomplicated software services, do it. If you can learn how to use open source software, powerful tools will be in your hands.

Tasks change over time, so software development is also changing. The task of this profession in the future is to enable ordinary people to use computers without spending half a dozen years studying. It is necessary to give users simple and understandable tools with the help of which they will independently solve simple tasks. And then the developers will move on to creating better tools, solving larger-scale known tasks, and will do everything possible to prevent the appearance of unknown problems.


About the translator

The article is translated in Alconost.

Alconost is engaged in the localization of games , applications and sites in 68 languages. Language translators, linguistic testing, cloud platform with API, continuous localization, 24/7 project managers, any formats of string resources.

We also make advertising and training videos - for websites selling, image, advertising, training, teasers, expliners, trailers for Google Play and the App Store.

Read more: https://alconost.com