Don’t confuse software development and programming
Every software developer knows how to program, but not every programmer can develop software
Most can easily learn to cook, but when a large number of people need to be fed, we hire a chef.
Perhaps some people prefer to say not “developer” more, but a software engineer, because an engineer – that sounds proudly! Or not? Fortunately, this article is not about terms. If you don’t like my term – substitute your own: “software author”, “software master” … and even “application creator”!
When I say “software developer” I mean a 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 something more than just making money.
It is not enough to know how to program to become a developer.
Anyone can be taught to program – it’s easy. Almost anyone can write simple programs that work for specific people on specific machines, but no one can guarantee that the same programs will work under different conditions.
I like this analogy: everyone can sing in the shower for their own entertainment, but you don’t put on tracks with recordings of this singing at a party – you are turning to the works of professional musicians.
Want more analogies? You are welcome:
We were taught math and writing at school, but that did not make us mathematicians and writers.
Most can easily learn to cook, but when a large number of people need to be fed, we hire a chef.
Nobody calls a neighbor – a jack of all trades to build a house from scratch.
The main goal of this text is to convey that creating simple programs is seriously different from software development.
Programming in its simplest form is the transmission of instructions to the computer to perform some action with some input data in order to obtain some output.
Software development, on the other hand, is the design, writing, testing, and support of computer programs to solve problems for many users; it is about creating robust, secure solutions that will stand the test of time and handle some of the previously unknown problems that lie in an area close to the obvious original problems.
Software developers thoroughly study the problems to be solved, fully understand how their proposed solutions work, how these solutions are limited and how they are characterized in terms of data privacy and security.
And if someone does not understand the problem, he should not be allowed to develop a solution for it.
Software developers don’t just write programs as their job – they think in terms of meeting needs and solving problems. And this is important, because not every task requires writing a program: in some cases, it is enough to use an existing program or combine several programs. And by acting proactively, sometimes you can get rid of the need to solve this problem altogether: the development of good programs often involves planning that allows you to prevent the appearance of certain problems and related tasks in the future.
For complex tasks, you have to write several programs. In some cases you need programs that run in parallel, in others you need programs that run sequentially. Sometimes it is enough to train users to solve a problem.
Before writing the code, the developer will ask the following questions:
What tasks am I trying to solve?
How can you solve the problem without programming?
What can be done to make it easier to write code to solve a problem?
High-quality programs have easy-to-read and understandable code, they can be easily extended, they work well with other software, and their maintenance doesn’t turn into a nightmare. Code quality should not be compromised; the use of quick but sloppy decisions due to a tight deadline, excessive excitement, agitation, irritation, etc. is unacceptable.
One of the most important aspects of software development is designing an expandable product from scratch. Modifying apps after they’ve been released is a fact to come to terms with. Users will need more and more functionality, they will want to make using the application even easier.
An application component is usually not very useful on its own. Software benefits begin when multiple components interact with each other, exchange data, and work together to present data and interfaces to users.
And with this in mind, you need to develop programs. What messages does the software accept? What events does it track? What messages does it give? How are data transmission authenticated and authorized?
The readability of the code is much more important than it might seem. Unfortunately, there are no convenient indicators for assessing this characteristic. It is helpful to memorize proven programming techniques and patterns, but this is often not enough. A good developer with experience simply develops an intuition that tells you how readable the code is. Here”s a good comparison: it isn”t enough to have a large vocabulary to write concise text.
With any program, at some point something will go wrong. The main feature of good software is the ability to easily fix an already released program. If the program generates an error during operation, there should be a clear message about this, which will be centrally recorded somewhere – so that errors can be tracked. When a new error is reported, 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 system component.
Working environment and testing
When a developer writes a program, he makes sure that it works in many different environments, on machines with different resources, and in different time zones. The software should run on screens of various sizes and orientations, with limited memory and low processing power.
For example, if software is written for a web browser, it should work on all major browsers. When creating classic software, in most cases it should work on both Mac and Windows platforms. If the application you are creating depends on receiving data, it should continue to work even if the data connection is slow or even completely absent for a while.
To write a software component, developers try to think through every possible scenario imaginable and plan to test them. They start with what is called the default scenario (or “happy path”), in which nothing unexpected happens, and all possible problems along the way – which is important – are documented and a test is planned for each. Some developers start by writing “test cases” that simulate such scenarios. They then write functional code that passes these test cases.
Developers need to understand the requirements for software, which are often ambiguous and incomplete. A developer”s skill is not in how he writes the solution, but rather in what solution he sees fit.
Cost and efficiency
In most cases, the developer can solve the problem quickly. If you think that hiring experienced programmers is costly, 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 run.
In addition, the “cost of operation” of the program should be taken into account: any software consumes computer resources, and they are not free. The developer will write an efficient program that will not use PC resources unnecessarily. To do this, he can apply, for example, caching frequently used data – and this is just one of the probably thousands of tools and methods that help to increase the efficiency and speed of the program.
Perhaps a novice programmer will provide a cheap solution, but working with this solution can cost you and your clients much more than if you immediately hired an experienced developer who is primarily looking for an effective solution.
The convenience of use
Good software is designed with computer user experience (UX) in mind, and this is a pretty broad topic with a lot of research and results. The more lessons learned from these studies are taken into account, the better the software will be in use.
Let me give you a couple of examples so you can get a feel for why this is important:
Well-designed software in user input forms will not be case sensitive in the email field and will remove leading and trailing spaces. There is no need to make life difficult for users due to the fact that they have CAPSLOCK enabled: the email address is not case sensitive. If the program accepts new email addresses, check them in advance and inform the user in understandable language that he may have entered an incorrect address. This also means common mistakes – for example, the absence of the @ symbol – and less obvious ones: for example, the misspelling of the popular domain: “gmail.com”.
If the user needs to be redirected somewhere, a good program will remember the starting point and, after performing the necessary actions, will return the user there. She will also remember already known data and interactions that need to be associated with subsequent steps of the user.
For example, suppose you searched Expedia for flights as a guest without logging in, and then decided to create an account. All previous searches 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 users” work in it. You can”t just add some features – you need to put yourself in the user”s shoes. I booked a United Airlines flight the other day and forgot to add my frequent flyer number. After receiving 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 through all the links that, as it seemed to me, could lead to the desired functionality. Finally I found the right page: it turned out that the last time I did not notice the required field, because it was buried deep in a large form. As a result, I needed to edit the passenger data, scroll through 20 input fields on this form, select the desired number type and be sure to enter the 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 hobbyists is that professionals know they have a responsibility to create secure, secure solutions.
A software component must be resilient to bad data, incorrect states, and incorrect interactions. It is VERY difficult to achieve such resilience – which is why we constantly read about how someone died due to a software bug.
Users will enter “bad” and incorrect data into the software. Someone will do this on purpose – in order to hack the software and get to the resources that the software represents. The employee allegedly responsible for the security breach in the American credit bureau Equifax, which was exploited by the attackers, was accused of not doing his job: he had to provide resistance to “bad” and malicious data in all software, openly published on behalf of the company …
The security challenge is not only about “bad” and malicious data, but also about normal data. For example, if a user has forgotten their password, how many times can they try to enter it? Should I block it after exhausting input attempts? 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 sign in from an unusual location? What to do if you suspect that you are logging in automatically?
How do you protect your users from cross-site scripting and cross-site request forgery, male-in-the-middle attacks, and simple social phishing? How to develop a backup strategy in the event of a DDoS attack on servers? The listed issues are just a small part of the many issues that need to be considered when designing.
Protected programs store confidential information not in plain text, but as one-way encrypted data with difficult-to-crack algorithms. This is a backup protection in case of software hacking and unauthorized access to data: hackers will get encrypted data, which in most cases will be useless.
An application might go into an error state and need to be fixed: even the best programs have unexpected problems. If you don”t take this into account when planning, you are not a professional developer, but just a coder 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 value good tools that help them write correct code and create secure software.
Obviously, we need more tools and we need better tools. In software development, tools are important, but they are often underestimated.
Any tool that shortens the feedback loop when writing code is a great addition. Using and perfecting tools is one way to get closer to this bright future.
When I find a great tool, I only regret not using it before. The better the tool, the better programs are written with it. Seek, use, and value them, and if you can, improve.
Becoming a software developer
It is impossible to learn how to develop software in a couple of months, six months, or even a year. You won’t be made a developer in programming courses. I started studying 20 years ago – and continue to study today. It was only after ten years of training, during which I had to design, build and support applications used by thousands of users, with sufficient confidence to call myself an experienced programmer.
Software development is not for everyone, but everyone must learn how to solve their own problems using computers. If you can learn how to write simple programs, do it. If you can learn how to use simple software services, do it. If you can learn to use open source software, you have powerful tools at your fingertips.
Tasks change over time, so software development also changes. The challenge for this profession in the future is to enable ordinary people to use computers without spending half a dozen years on training. It is necessary to give users simple and understandable tools with which they will independently solve simple problems. And then the developers will move on to building better tools, solving larger known problems, and doing whatever they can to prevent unknown problems from occurring.