(click to listen)
A few days ago, Xiaohongshu IosApp users reported that the app crashed and could not log in. Then this topic quickly appeared on the hot search list, which attracted the attention of fellow programmers.
Subsequently, Xiaohongshu customer service microblog issued a statement, acknowledging the flashback problem, and said that it was caused by a technical failure, saying that it is doing its best to fix it
However, what attracted more attention in the programmer circle was a screenshot on the Internet. A user suspected of being a developer of Xiaohongshu posted a Weibo, claiming that he had been sacrificed to heaven, and apologized to the user.
Online accidents like this should be at the p0 level. Someone in the team’s R&D team must take the blame and be responsible. Either lower performance or deduct bonuses, but because of a technical failure, blame it on a certain programmer and fire him , obviously a more sensitive and aggressive reaction
In the process of software development, bugs are unavoidable. Whether it is a large-scale application such as Xiaohongshu or other small application software, technical failures, flashbacks, and data failures may occur.
A new function on a product release line, or a bug modification, requires a strict process , from requirements review, front-end and back-end development, joint debugging, environmental testing, etc., and even code review, only when there is no problem will only be published online
Software development is a complicated process. For laymen, it may feel that software applications are written by programmers, and the programmers who write them should be responsible
There is even a very absurd question on Zhihu, why can’t programmers’ codes be held accountable for life?
This is obviously a layman's view. In the company, the development of software programs is done by team members who are responsible for different modules. Finally, they can be released and launched after the tester passes the test.
For a large application, there are different members responsible for development and maintenance, including front-end and back-end development, testing, and operation and maintenance. In the end, it is really unfair to attribute all the problems to a certain programmer.
The flashback of the program application may be caused by various factors, such as: network lines, third-party libraries that the program depends on are loaded incorrectly, etc.
Some problems are beyond the control of programmers, such as: a dependent library in the application is deleted by a third party, or system compatibility issues
No one can guarantee that the application program written by oneself can run perfectly under any circumstances, and if there is no error, it can be solved in time when there is a problem
In the process of software development, programmers need to write high-quality code and conduct sufficient testing, but if the time is tight and in a hurry, it is inevitable that the quality will not be guaranteed and no mistakes will be made.
Due to the complexity of the project and time pressure, some boundary issues may not be considered, thus ignoring some special cases
As long as you can actively follow up and fix bugs, I think it will be fine, but this kind of direct dismissal of a programmer is indeed a bit violent
This kind of behavior does not solve the problem, it should be cited as an example to improve the development specification process
This kind of violence is quite chilling, and it is easy to cause instability among team members. Although everyone will become cautious and lack tolerance in the future, it is unavoidable to be a little chilling
But this is often the case in the workplace. It is not a school. Someone needs to bear the wrong results. Strictly speaking, the testers must also be held accountable, and the development is the last, but the fact is often the case. Once interests and responsibilities are involved, any problems will be Point to development, product success is also developed, failure is also developed
In Internet companies, those who do product development are under the greatest pressure, and they are the implementers of specific implementation
This kind of p0-level accident has also been reflected from the side. Even in the big head companies, there are still some flaws in the product development and online release process. In short, since something happened, someone will always be responsible. This level of application, the stability of the product is very important
The workplace is like this, not a school, someone needs to take responsibility for the result, even if the employee is not worshiped, the follow-up will inevitably be marginalized, or lose the trust of team members
The internet really can’t move anymore. The internet industry is like this. It’s cruel. If you can, you stay.
Search box deformation animation implemented using CSS3 transform:matrix3d
Pure css3 realizes element fixed-point ring diffusion animation
(can draw, can ask questions)
