Agile development process summary

Agile-agile developmentAs a new software development model introduced after the collapse of the CMM myth, it has been widely concerned over the past few years and has been highly expected. It is not clear whether agile development is ideal in other industries, but the following summarizes the agile development experiment of my company, hoping to gain a glimpse of it.

Agile Development declaration --
Individuals and interactions are better than processes and tools
Software that can work is better than comprehensive documents
Customer cooperation is better than contract negotiation
Responding to changes is better than following the plan
Although the right item also has value, we think that the Left item has greater value.

The above declaration is abstract. Based on this philosophy, the following are n agile development practices that thoughtswork consulting companies respect:
Iteration
Iterative development. Software that can work is better than comprehensive documents. Therefore, agile development advocates dividing a complete software version into multiple iterations, each of which achieves different features. Major and high-priority features are implemented first, and features with high risks are implemented first. The software prototype was developed in the early stages of the project, and the prototype was used for subsequent iterations at night. The advantage of iterative development is: code as soon as possible to expose the technical risks of the project as soon as possible. Enable customers to see the running software as soon as possible and provide optimization suggestions. You can deliver available versions to different customers in advance in stages.
Iterationplanningmeeting
Iteration plan meeting. When each iteration starts, the entire development team is called and an iteration plan meeting is held. all the team members speak freely, clarify the iterative development tasks, and answer questions.
Story card/story wall/feature list
In each iteration, the architect is responsible for breaking all the features into multiple story cards. Each story can be considered as an independent feature. Each story should be able to complete development and deliver pre-test within one week at most ). After all story in an iteration is developed, the test group performs a complete test. During the entire test process (pre-test, test), based on the daily build, the test group will always take the latest compiled version from the configuration library every day for testing, developers can also modify the problem tickets submitted by testers at any time and integrate them into the configuration library.
One feature of agile development is open office and full communication, including testing staff working with developers. Based on the story card development method, the team will place a whiteboard in the open office area, paste all story cards on it, and paste them in the four areas according to the current development status, respectively: not developed, under development, under prediction test, and under test. The story card developer and tester move the story card on the story Wall Based on the development progress to update the status of the story card. This method provides an intuitive understanding of the project development progress.
When developers start to develop a story, TA needs to find the corresponding tester to explain the story function, so that the tester can have a consistent understanding and start the development of automated system test scripts.
Standup MEETING
Standing Meeting. Every morning, all team members hold an efficient meeting around story wall, usually within 15 minutes, reporting development progress and asking questions, however, it does not waste everyone's time to solve the problem immediately. Instead, it will be resolved through communication after the meeting.
Pair Programming
Pair programming refers to the code of pairing two developers. The advantage of Pair programming is that the code written after discussion by two people is more perfect than the code written by one person independently. Some big directions will not be deviated, and some details can be fully taken into account. An experienced developer and a newbie Pair programming can promote the growth of newbie and ensure the quality of software development.
Ci/daily build
Continuous integration and strong daily building capabilities are an important foundation for successful iterative development. Built on a daily basis. Developers update the written/modified code to the configuration library in a timely manner every day. The automatically compiled program automatically removes the code from the configuration library at least once a day, perform automated static code checks (such as pclint), unit tests, compiled versions, installation, system tests, and dynamic checks (such as purify ). After these automated tasks are completed, a report is generated and an email is sent to the team members. If there are any problems, the responsible person should promptly modify them.
As you can see, the entire development group frequently updates the Code and some problems are inevitable. The test department continuously tests based on the latest code. Whether new problems can be detected and eliminated in a timely manner depends on whether the automated unit testing and system testing capabilities are strong enough, especially the automated system testing capabilities. If the automated test can only verify the simplest operation, the hidden risks of newly integrated code will be hard to be found and left behind in the later stage of the project, forming a great risk. In fact, improving the coverage of automated testing is the most difficult.
Retrospect
Summary and reflection. After each iteration, the project team members will hold a summary meeting to summarize the best practices and lessons and implement them in subsequent development.
Showcase
Demo. After each story is developed, the developer calls the tester to demonstrate the software functions so that the tester can fully understand the software functions.
Refactoring
Rebuild. Because the iterative development model developed a runable software prototype in the early stage of the project, the code and architecture developed at the beginning cannot be optimal and comprehensive. Therefore, in subsequent story development, code and architecture must be constantly restructured. Iterative development has high requirements on architects. Because architects need to split a complete version into multiple iterations, and each fall is divided into many story. From the perspective of architecture, these story must have strong inheritance, it can be superimposed constantly, so that the subsequent development of story will not completely overwrite the code and architecture of early development. At the same time, it is inevitable that the Code should be constantly improved and reconstructed.
TDD
Test-driven development. As mentioned above, iterative development features frequent code integration and frequent version release. Test-driven development is an important means to ensure that the integrated code runs normally and will not be damaged in the future. The tests here mainly refer to unit tests.

Reflection on Agile Methods:
The agile development project involved by myself is not very successful in general, which may also be a common problem in the industry:
1. For new software, testers participate in and implement automated testing scripts early in the project. However, the software interface is very unstable, resulting in heavy rework workload.
2. For the new software, the data personnel participate too early, and the rework workload is heavy in the future. The reason is the same as the first one.
3. The test workload of the automation system is large. The tester has invested a lot of energy to automate the test, but not enough energy to test whether the functions of the software are normal. Even so, the automated system test scripts are mostly in the form and cannot detect deep-seated problems.
4. The Code Dynamic Check tool is not ideal for execution and is in the form. No one has a deep understanding of purify and application experience. Many alarms are found in the report, but I do not know how to eliminate them.
5. Due to rapid prototyping and no rigorous design on the architecture, code has been stacked in the future.
6. In the remote development mode, rapid construction and delivery cannot be achieved, and the team is generally exhausted.
7. Agile development does not advocate overtime, but in fact, no matter which development mode is CMM or agile, it is not necessarily related to working overtime.