After Wu Tao finished speaking, Wang Youjie did not speak immediately.

Speaking of the unreliable things that Party A has done, there are many discussions at the bottom.

------ let's be honest, our nightmare as programmers is that we get a message at the end of the day, "We've made a little change, can you take a look at it again?" ”

------- even more nightmare is that after several days of overnight development, the other party said, "The leader has just changed his mind, and the previous function still has to be added." ”

-----That's right. What they say is always light, and it is not difficult for us programmers to take a look at it, that is, it is just to refactor the code, and it is enough to stay up all night for ten days.

------So, to kill our programmers, you don't need to use a gun at all, as long as Party A changes the requirements three times.

------

Of course, Wang Youjie, who has come over, knows these discussions.

Wang Youjie's personal experience is that, like other people in the workplace, in fact, many software developers generally have the existence that he fears. Specifically, there are three main fears:

One is the fear of nosy and incompetent bosses, including bad bosses and supervisors.

Software developers especially hate non-technical management that is free to interfere with their code. Some leaders like to commit to things that can't be done, underestimating the time it takes to slice the code in a project. The thought of such leaders and technical decision-makers makes some programmers cry even in their dreams late at night.

In addition, Party A's technical strength seems to be so "strong" that sometimes the person in charge of Party B who does not understand the technology has to be with the mud: let's go back and evaluate it again. At this point, the tech-savvy programmer can only stare wide-eyed below.

The second is the fear of having a bad product manager, which may even be worse than your own toothache.

These so-called product managers tend to think highly of themselves and expect programmers to meet any customer needs ahead of time. They also believe that programming is a small thing, and that code is floating in the air and can be easily accessed. "It's very simple, just get it a little bit."

The third is the boss and person in charge of Party A who are afraid of knowing a little technology, but like to command blindly.

Just like the situation that Wu Tao is experiencing now.

Truth be told, software developers always prefer application requirements that are clearly articulated and cannot be changed. In practice, many requirements are hastily formulated, sometimes even formalized; The reason for the change is partly because of the bad project manager, and partly because of the complaints and interference from the superiors or the customer itself.

In short, the fear of requirements changes – especially last-minute requests – will always be a big deal for developers, regardless of the reason.

Wang Youjie thought for a moment and looked up. After he stopped talking, he said: In this way, Xiao Wu, the next time you have a demand meeting with Party A, I will also participate. Okay, right? ”

"Of course that's great, what's not to do?!" Wu Tao immediately laughed.

After this matter was finished, another group leader began to report.

What he was talking about was still the same issue about documentation that had already been raised at the last meeting.

"It's no exaggeration to say that whoever slices up code without documentation, or maintains old software without documentation, is a nightmare for me."

"As everyone in this room knows, it's hard to sit down and understand a piece of existing code that isn't well documented or commented. However, it's even worse if there isn't even a document or annotation. ”

Good documentation is missing, or even no documentation. This situation in the Shanghai branch Wang Youjie was only known after he worked for a long time.

However, it is important to know that for most programmers, whether they like it or not, they still have to continue working on someone else's code. At this point, even a well-documented piece of third-party code can become a nuisance, requiring you to debug, refactor, or structure the code to fit into code that may have been sliced up months ago.

When it comes to code editing, each programmer has their own unique coding style. So every programmer looks at everyone else's code and it's almost all bad code. Once a programmer changes jobs, there will inevitably be other programmers who take over his project, but when you look at the code, especially the code that doesn't write comments, you can see that the programmer's hair is actually scratched by themselves a lot of the time.

It probably doesn't stop there.

The code was finally written, and I just took a breath and was ready to start the next job, but the company leader said that I should also fill in the documents and write the meaning of the interface parameters. At this time, the programmer is usually unhappy and resistant, and the result is naturally to write a document hastily.

Why, because the code that implements the functionality is the work that reflects its own value and makes money, and the documentation seems to be just an add-on. When the work is done, who wants to work more?

Besides, does the time it takes to write documents be included in the workload estimation? You didn't give me time, and now you still let me write, don't you make me work overtime?

Wang Youjie once suggested to the manager and the branch office a long time ago: "If you want to do the work beautifully, with both elegant code and perfect documentation, you must set aside time for the documentation work." ”

After thinking for a while, I was about to speak, "---- Di", and a text message came in. Wang Youjie looked down, but it was Bu Li: Can you set your time?