Personal Understanding about "Silver Bullet" and "big mud ball" in the second reading assignment

Over the past few days, I have been able to read the paper proposed by the teacher by means of English translation. I feel that their thinking is different from ours. In our opinion, the task of writing code is only to implement the functions in the design document, these are often able to meet the requirements in the curriculum design, but in the long term and the perspective of software optimization, our design is extremely bad .....

From the master's point of view, the most essential thing for programmers to implement software is that software is in two aspects: Conceptual abstraction and computer application. It is very difficult to design abstract software solutions, software Implementation and computers are also challenging. Inspired by the master, I have understood the four difficulties as follows:

1. complexity: computing steps are indispensable in software design solutions. Human abstract activities often complicate the process of software development, and each programmer has different ideas and abstractions, in our code implementation, we often get time optimization only when it involves simple algorithm steps. However, for each different actual situation, the time resource consumption corresponding to the algorithm will also be good or bad. As for the optimization and optimization algorithms, we often need to combine various possible situations and calculations, which is very difficult for us.

The conceptual hierarchy is an extremely abstract hierarchy. For truly implemented code, the conceptual hierarchy also involves the use of dependency and flow control between a lot of data, it is impossible to completely solve the problem at the conceptual level, which is more difficult for large projects.

2. concealment: we cannot correctly assess unfinished code projects because their structures are not completely apparent. As a team development, we often cannot communicate and negotiate in a timely manner. In previous Personal and team programming, we often complete the code after completing the code editing task and the personal development module, but this is actually not a scientific method, if the structure and calculation can be summarized and corrected in a timely manner at the same time, the quality of the code can also be improved, but this method is very difficult for us.

3. controllability: for large software, changes may occur to the interface and other communication parts of each module due to actual changes in time and environment, so maintaining consistency will often cause headaches. There is always no such concern about programming and training of courses, but in actual software development, the cooperation protocols between module programming and the synchronization of changes according to actual conditions are also the embodiment of code quality, the Coordination consistency of subsystems is often difficult to maintain during environment changes.

4. variability: after all, the application of software is not static, but implemented under a certain requirement. However, in actual situations, changes in environmental factors such as demographic requirements, hardware, and application fields often result in a compromised nature of the software's appropriate requirements. We will also say that the implementation of software often meets relatively complete requirements for some established demand designs, but it is not optimized in another changing environment, software variability to cope with such changes is also a challenge.

In the process of personal projects and paired projects, we focus on the implementation of Algorithm functions. For algorithm optimization, we only have some concerns, but this is only a local solution, for example, in the word statistics CPP, my algorithm solves the requirements raised by the teacher, but it consumes a lot of time resources when facing big data queries, in addition, the Code algorithm is not the most suitable optimization algorithm for solving the problem, so it is of no practical use. In the elevator scheduling scheme, there is not enough communication between two people's programming. It takes a long time to correct a lot of problems only when the Code connection is found. The above four aspects make software development more difficult. The affiliated difficulties of the current unified programming language and software have been greatly improved. For our current capabilities, we have a solid knowledge of algorithms, cultivate a good sense of cooperation and communication skills, learn to draw the opposite line from each other, and consider the above four situations in early software development. I believe our ability training and the quality of software development have been improved.

Looking back at my own code, it's almost the same as the "big mud ball. The definition of a large mud ball refers to a random system. It is embodied in the arbitrary code stacking and patchwork, which often brings difficulties and many errors to software development. The goal of each of us is nothing more than writing code with strict logic thinking, compact structure, and easy to read and maintain. This is conducive to the mutual communication of software written by many people and the maintenance and style of code. However, we also want to say that it is impossible for every program to be perfect. In the case of the aforementioned variability, the works we design can often better be mapped to a user requirement, often the actual situation changes will cause bugs in our design, and the software design itself has to generate and solve a lot of bugs. Therefore, we have to reflect on the negative effects of avoiding the time benefits brought by the "big mud ball" Software Design:

The requirements of users must be comprehensively analyzed. Considering the special circumstances, the solution must be flexible while solving the above problems, not limited to the current needs.

The Code style should be clear, and each part should have specified requirements instead of adding bricks and vinegar. Be able to have a deep understanding of programming languages and environments and learn to use existing resources to simplify code.

The software development room should have rich enough communication and communication to dynamically discover and solve problems, and be able to correctly evaluate each part of each stage.

In general, inadequate preparation, fragmented growth, lack of skills, and communication are all factors of "big mud ball.

In terms of optimization and testing, the methods used to search for three different requirements in the Code are redundant and cannot be used flexibly to simplify the format of the class library, this greatly increases time requirements. In terms of team design, inadequate understanding of algorithms makes the algorithms meet requirements in most aspects of solving problems, but in special cases, it is GG. Therefore, in the three process phases of algorithm design, code writing, and debugging and testing, we should make some research and optimization.

At this stage, for software development, there are still some essential problems that cannot be solved, but people are also actively studying various advantageous and development and debugging methods, for example, the unified programming environment and programming language and time slice sharing, the advanced language enables us to focus on the design of methods rather than the underlying assembly information, although the concept of implementing the conceptual model in advanced languages does not give up some efficiency (for low-level languages), it makes software development easier. Many programming library classes and frameworks are also provided for the programming environments of different programming languages. We reference the libraries that can simplify the code and indirectly unify the interfaces between modules, is the completion of personal modules and module docking provides great convenience. This is of great inspiration to us.

Finally, the understanding of the software engineering methodology, the article said, the method is invisible, but not metaphysical. I understand that the number of lines of code reflects the simplicity of the code, but it cannot fully describe the capabilities of developers. The measurement of the successful development of software seems to be able to fulfill the expected requirements, however, few people know that the project fails successfully, and the actual software is complex and irregular. When writing code, we may also encounter problems, such as incomplete algorithm vulnerabilities and incomplete communication, which may lead to debugging difficulties. For each programmer, we should all improve our professional qualities and abilities through continuous attempts and practices. The article finally emphasizes the establishment of an organization with strong learning and adaptability, I think that there are many variables in the development of software engineering. Different Environments, requirements, thinking directions, and cooperation organizations may lead to many difficulties in software engineering, therefore, you cannot evaluate a person or group globally by code or function. We cannot rely too much on groups. The division of labor among the groups completes their respective tasks and constantly communicates and improves to achieve optimization. This is not just a practical process, but a task, it is also an embodiment of personal ability improvement and software quality. For us, we can improve our algorithm design and code programming capabilities in a timely manner and do our part well, at the same time, teams can adapt to each other and work in a timely manner, so that the effect of software engineering can get better and better.

For Pair programming, my teammates and I are relatively independent in the two phases of code understanding and coding respectively. Lack of discussions on module interface consistency and Algorithm Research, as a result, the algorithm originally designed is not very effective. In the second design, we carefully studied the source code, clarified the interface definition implementation, learned the advantages of both sides, and improved my code programming capability, at the same time, I have a new understanding of the algorithm, and the programming style of my teammates has also been improved. In short, the software development methodology is an abstract concept with no definite principles. It should be practiced only with its own constraints and the focus of coordination between teams.

So I reviewed the course of programming at the beginning of school, and I also had many problems:

1. The design of algorithms is incomplete and cannot be "Think Twice ".

2. code optimization needs to be improved to reduce redundancy and use the same library and framework.

3. Lack of communication, team projects should learn from each other in algorithm design and implementation, and have good specifications to ensure smooth software development.

We hope that we can optimize the program as much as possible in the future, avoid the "big mud ball", participate in a lot of team projects, learn to improve our own capabilities, communicate in a timely manner, and evaluate the program in a timely manner, improve the software development speed and the quality of merger; cultivate innovative thinking and make breakthroughs, and move toward specialization step by step.

Personal Understanding about "Silver Bullet" and "big mud ball" in the second reading assignment