10 common problems faced by programmers

[[221521]]

The most difficult task for programmers has little to do with writing code. Coding is an exercise in logical thinking, which is relatively simple compared to other tasks in a programmer's daily work. If you consider yourself an average programmer, make sure you have overcome the following obstacles before you can truly enter the ranks of masters.

1. Explain what you do

Explaining the software development process is a difficult thing. Those who are not programmers may know a lot about programming, but obviously, they can't program. For them, our life is to spend coffee in front of a keyboard in a dark room.

You will come across people among your friends, family, and colleagues who think coding is not a proper career.

2. Describe the software solution in a vivid way

Based on some brief requirements, which are usually half-understood, you need to design data structures, software architectures, code algorithms, communication protocols, and all other components of solutions to business problems. Then you need to express them in terms that laymen can understand and submit them to customers within the specified time.

Few programmers can do this well.

3. Evaluate the duration

This is the source of programmer pain. Before the development task is completed, you will never be able to determine how long it will take to complete the task. The program may be very similar to what you wrote before, but the environment has changed, the problem has changed, and the constraints have changed.

Experience provides some judgment, but most programmers tend to underestimate the difficulty of a problem because they only consider the coding aspect and ignore the other items on the to-do list.

4. Maintaining other people’s code

There may be 10,000 solutions and 10,000 ways to write a problem. Taking over code written by someone else means you have to spend countless hours exploring thousands of lines of code to understand the original author's thinking. Moreover, if it is a half-project left by a programmer who does not believe in comments and documentation, the trouble is even greater.

5. The blurring of software boundaries and the bizarre functional requirements that make people vomit blood

While agile development methods provide some room for scope inflation, it doesn't help - especially when you have a feature request that was created on a whim. You know it will fail. Your team knows it will fail. But the customer is fine with it, and when it inevitably fails, it's all your fault because you didn't understand their true intentions.

6. Find the balance between under-optimization and over-optimization

Complex software is never perfect; there is always some better way. You can optimize endlessly, which is why software projects are never finished early.

On the other hand, the "it's fine - I'll improve it later" mentality is also common. The code works today, but you know it may be broken or not work tomorrow. Of course, you don't need to fix it, it will be left to the next unlucky programmer.

7. Test your code

You have written unit tests and submitted the software to the testing team, but bugs still exist...

Software is complex and may contain tens of thousands of lines of code. There may be millions of different interactions and logic paths in the system; you can't possibly test them all.

Similarly, software interacts with different software on different platforms under different conditions. You can't test them all.

Writing good unit tests is boring and hard work. Ideally, the tests should be written before development begins - but how do you explain to a client why four weeks have passed and there is still no working software?

Unit testing cannot cover every problem point. In an ideal world, there should be an independent team writing tests and actively finding problems. Unfortunately, for most projects, this is too costly and time-consuming, so the development team is used to write tests. The development team subconsciously avoids many extreme edge cases.

Programmers like to solve all problems in a logical way. But users rarely do. They will find problems that you never expected.

8. Write software documentation

Writing documentation for code is a laborious and time-consuming task. Few programmers are good at it, few enjoy it, and few take the time to read it.

9. Dealing with IT issues

You work with technology every day. You may be an HTML or PHP programmer, but you will most likely encounter problems such as hard drive corruption, driver conflicts, or software crashes. It is not your primary responsibility to solve these things, but unless you solve these problems, you will not be able to continue your development work.

Unfortunately for those outside of IT, programmers are supposed to be proficient in both hardware and software. When they have a problem, they don't spend time solving it themselves, they come to you directly. No matter what the problem is: you are a computer user, you must know how to import a budget spreadsheet into Sage, how to configure Oracle, or why they can't send emails on their Blackberry.

Of course, these interruptions are no excuse for not getting your work done and not getting paid, right?

10. Dealing with people issues

All of the above problems can be summarized as "people problems". Few laymen would advise a pilot on how to fly a plane or advise an electrical engineer on how to wire. But many people would enthusiastically and bravely advise on how to develop software.

I believe there is no good way to deal with these people. You need to accept the fact that half of the world's intelligence is below average!