The difference between agile development and code writers without specs, without documentation
Contrary to some opinions, agile developers are not mavericks who write code without rules or restrictions. "Cowboy coding" is a sign of a lack of rules and poor management, and is very unprofessional. If there is such a phenomenon of writing code on your team, you should do everything in your power to change it for the benefit of the client.
What documentation does agile development require at least to develop and maintain?
But the reality is that most people don't like to write documentation, and they don't like to study documentation, so too much documentation will only consume the team's limited time and not bring much benefit;
A brief high-level document is a contract between the user and the development team, and a consistent understanding between the two parties facilitates communication and interaction; the user only cares about what he wants, not how to implement it, let alone how difficult it is to implement. So we can't expect users to understand the technical problems we encounter, or even read our code or comments;
Agile development attaches great importance to the role of documents and the maintenance of documents; it believes that documents should be small and refined. Generally, it is recommended to develop and maintain three documents:
"Software Requirements Specification" or "Product Specification": Define the functions, boundaries, etc. that the software should have, so that the software-related stakeholders have a consistent understanding of the software, which serves as a common basis for discussion between users and the development team, and Continuous update and maintenance during the development process;
"Architecture Design Document": How is the software implemented and what is the relationship between the internals?
Project Management Plan: how the plan will be implemented, tested, and released in stages;
Does agile development require system design?
Agile development replaces large cycles with small cycles. Small cycles include: requirements, design, development, testing, and release. This process includes the design link, which means that system design needs to be done;
Since a complete design requires relatively complete data and a relatively long time, which is opposite to a small cycle, agile development does not advocate highly detailed and complete design, but advocates making a large-grained framework design. Refers to the architecture design or the system design or the outline design of the functional modules, to avoid changes in the architecture level in the subsequent refactoring, and then gradually expand and refine in the process of gradual implementation;
Just do a general design, not a detailed design. [You can divide modules, classes, public interfaces].
The implementation of the class can be directly determined by the coders. After the project is completed, the implementation model and class relationship diagram of the class can be obtained through post-processing tools.
Some traditional design methods such as structured design, object-oriented analysis (OOA), object-oriented design (OOD), top-down and rapid prototyping methods can be integrated into the agile development process and used;
Does agile development require a project plan?
Commercial software development needs to assume the responsibility of making profits, so it has high requirements on the functional integrity, stability, immediacy, etc. of the product. It is an organized and targeted behavior, so it needs project planning, but this A plan is a short-term plan, based on unimplemented features, feedback from the previous version, and organizational goals; only in this way can new changes be continuously incorporated;
Annual planning, monthly implementation plan. [The annual plan is generally immutable, and the monthly plan can be based on the actual situation to schedule the realization of the demand]
How long is the iteration cycle of agile development?
For general small projects, a large feature release can be delivered monthly, and a change or bug release can be delivered every two weeks. When estimating the progress of the project development, it is necessary to have a rough plan for the content to be delivered.
Of course, it cannot be released frequently, especially the urgent release of major bugs, which will reduce user expectations and increase user costs, which will bring additional psychological burden to users: he will think that the product quality is low, and the quality control is not rigorous, etc.;
Why does agile development advocate small versions? What are the advantages of the small version?
The purpose of small releases is to decompose complexity, reduce risk, improve team morale, etc. Small releases have many advantages:
Ⅰ. Less overall risk: Small version changes are small, and it is always partially adjusted and added on the basis of the previous version, and the technical complexity is low; because the planned functions are less and the workload is easy to estimate, the overall risk is relatively small, Often published on schedule;
Ⅱ. The ability to accept requirements is strong: because the small version is quickly implemented and released for testing, it will then enter the planning and implementation cycle of the next version, so that once new requirements are proposed, they can quickly enter the development vision and can be realized as soon as possible;
Ⅲ. Efficient collaboration between testing and development: development and testing can work in parallel. When the first version is developed and implemented, the test plans and use cases are designed for testing; after the first version is released, the development will enter the next version round, and the test will be applied The test plan tests the version just released and submits bugs; the development corrects all the bugs found in the previous round at the end of the next version, and then releases the new version, and so on, and the development and testing achieve efficient cooperation;
How does agile development relate to refactoring?
Agile development is based on refactoring and is in the process of refactoring all the time;
Why does agile development emphasize the participation of team members and users?
People are the main body of all relationships and the main body of productivity improvement; agile emphasizes the high participation of team members is to unify the understanding, turn the team's goal into each person's work goal, so that it can be recognized by each team member and form a high degree of Cohesion, in order to achieve the effect of collective efforts and efficient cooperation;
Since there is no highly detailed document, the only channel for exchanging information between members is face-to-face communication. A good team atmosphere and collaborative relationship promote this communication and make the message accurate and effective;
Due to the lack of professional training, users cannot express their intentions clearly and accurately, resulting in ambiguity and ambiguity of needs; users' participation makes vague and uncertain needs confirmed and improved in the process of interaction;
What we strive to do is to achieve what users need, and finally let users like it. Only when users like it can we use it well, so how can we not listen carefully to users' opinions?
In one sentence: User engagement helps us do the right thing!
How can we assess how agile our teams and development processes are?
Since there is no standard practice process for agile development, it is difficult to judge that its development process is agile through a certain process, so how do we evaluate whether our team and development process are agile? The method used here is to evaluate whether the team and its development process are agile according to the atmosphere presented by the team, the project operation status, and the perceptual knowledge of team members. We believe that the methods for evaluating whether the project team and development process are agile are as follows:
1. The team has a common vision and is confident in that vision
2. The team has a clear stage goal and is known to each member;
3. The team knows the current plan: what to do, when it will be done, expected results, etc.
4. Team tasks are low-coupling and work closely together;
5. The release process is easy and pleasant, and building versions and continuous testing is one of the normal behaviors;
Can agile development reduce project time and improve quality?
Can agile development shorten project cycles and improve overall quality? Yes, but I cannot provide quantitative data for reference at present, and can only evaluate and infer from several aspects: agile development can shorten project time and improve quality;
1. User participation helps the team to complete the function at one time and do it correctly, reducing the time for rework;
2. Continuous refactoring and test release can find problems at an early stage, and the overall quality is significantly improved;
3. The process goal orientation makes the team highly focused on the project goal and improves the productivity;
4. Continuous release is a positive incentive for the team, and the sense of honor and success will keep the team with continuous passion;
The biggest difference between agile development and CMMI :
I think CMMI is a process from big to small, and Agile is a process from small to big.
CMMI is to give you all the points you may need to consider and let you choose what you may need
Agile is to give all the points that must be considered, and then let you expand on it
It doesn't matter whether the method is good or bad, the key is to choose the right method and use the right method. If you only discuss the theories in these books, it is inherently flawed.