Ron Jeffries 11/08/2001
translation:
XLP223 2001/12/06 Chen_QJ 2001/12/07 Notyy 2001/12/06 BrokenDoor 2001-12-14
sort out:
BrokenDoor 2001-12-18 -------------------------------------------- ------------------------------------
Extreme programming
(EXTreme Programming)
It is a development discipline that is based on simplicity, communication, feedback and courage. Its approach is to closely link the entire team with a valid practice rule. Through full feedback, the team can always know your current situation and the appropriate regulation rules to adapt to your own special circumstances.
In extreme programming, each project contributor is
"
team
"
Complete part. This team is a commercial representative that surrounds a weekly and team sitting together.
- "
client
"
Established.
Core Practice: Overall Team
Extremely programmed teams use a simple way for planning and tracking to determine what will be done next and predicting the project. Focus on business value, the team creates a software system through a series of tested tests and fully integrated small releases.
Core practice: planning strategy, small distribution, customer test
Extreme programmers work together by pairing and group, and the continuous improvement of design and mandatory code, the design is always suitable for the current demand.
Core practice: Simple design, pair programming, test priority development, design improvement
Extreme programming teams always keep the system to be integrated and run at all time. The programmer writes all product code in pair and works together in all times. They encode similar forms to ensure that all members can understand and improve all of the code as needed.
Core practice: continuous integration, collective code ownership, coding standard
Extreme Programming Team Share a public and simple system blueprint. All members can work according to a rhythm that is synchronized from time to time.
Core practice: system metaphor, acceptable pace
Core practice
Team overall
One
XP
All participants of the project are sitting together as a member of a team. This team must include a representative of a business
- "
client
"
He provides demand, sets the priority, and takes over the direction of the entire project. It is best to be a end user, understand what is needed. The team, of course, there must be a programmer. The team may contain testers, helping customers define customer acceptance testing. Analysts can use the customer's assistant to help customers define the needs. Often there will be a guide
,
He helped the entire team to track and promote the development process. There may also be some administrators who provide resources, handling foreign exchanges and division of labor. Nothing in these duties is a must have a uniqueness: every one
XP
The team members participate in any way they can do, the best team does not have an expert, only some of the general participants with special skills.
Planning Strategy
XP
The plan to resolve two key issues in software development: pre-knowledge which things will be completed during the responsibility period, and make sure what needs to do next. The focus is to grasp the correct track of the project
-
This is quite simple and clear.
-
More than hopes to accurately predict which things will need and how can I spend?
-
This is quite difficult. in
XP
There are two key planning steps here to solve these two problems:
The publishing plan is a practice that allows customers to demonstrate the features they want, and then programmers evaluate their difficulty. When there is a price assessment in your hand and the cognition of important procedures for these features, the client arranges a project plan. The initial release plan needs enough room: priority and assessment is not true and reliable, and we can't understand the development schedule of the team before the team starts working. Even the initial release plan is not enough to decide enough, so XP
Team usually corrects the release plan from time to time.
Iterative Program is a practicality that can provide the team to provide the guidance of each developing week.
XP
Team through two weeks
"
Iterative
"
To establish a software system, provide a software system that can run at each iteration. At the time of the iterative plan, the character of the customer wants to complete within two weeks. Programmers divide them into several tasks and evaluate their costs (some more than the release plan). Based on the work completed in previous iterations, the team signs the work that will be undertaken in the current iteration.
These plans are very simple, but they provide customers with very good information and excellent manipulation control. Every few weeks, how many progress can be aerated. in
XP
No
"
90% completed
"
: A character story is either completed, or no completion. Focusing on the visual results method is a good small opposite argument: On the one hand, it is very intuitive. If the progress cannot be satisfactory, the customer can cancel the project in a certain position. On the other hand, the progress is obvious, and it is very perfect to determine which things will be completed, so
XP
Projects often do more required things under less pressure.
Customer test
As part of each of the desired characteristics,
XP
Customer defines one or more automatic acceptance tests to indicate that features have been implemented. The team implements these tests and uses them to prove the characteristics of themselves and the customer has been properly realized. Due to time pressure, automation is important, manual testing will be skipped. This is like when the night is coming, you can turn off your lights.
the best
XP
The team will treat their customer test as the test of the program: Once the test is running, the team will keep it can operate correctly. This means that the system can only be improved, always forward, never go back.
Miniature release
XP
The team practices a small release from two important ways:
First, the team can run, tested software systems, and provide customer-selected commercial value. Customers can use this software system for any purpose, whether it is an assessment or released to end users (strongly recommended). The most important way is that the software system is visible at each iteration, and is submitted to the customer. This guarantees that anything is open and real.
second,
XP
Teams have spread to their end users as much as possible.
XP
The website project is released every day, and the home project is released monthly or more frequently. Even the product that can be easily upgraded can be shipped every quarter.
It may be unlikely to create a good version so frequently, but
XP
The team is released every moment. MORE INFORMATION
XP
The tests visible everywhere (as described in customer testing and test priority development) become reality.
Simple design
XP
Team Construction Software System is a simple design. They maintain a simple design from the simple start and in the entire programmer test and design improvement. One
XP
The team maintains the design is always suitable for the current functional requirements. There is no extra investment here, and the software system always prepares for future.
in
XP
The design is not a one-time thing, nor is it a matter from top to end, it is from beginning to end. There is a design step in the release plan and iterative plan, and the team's ability is collected in the fast design process and improves the design throughout the project. In the increment and iterative process similar to extreme programming, good design is essentially. This is why you must pay more attention to the design of the design throughout the development process. Pair programming
in
XP
All product software is shared by two programmers and is done in the same machine. This practice ensures that all of the product code has at least one other programmers to review, and the result is a better design, better testing and better code.
Let two programmers do
"
A programmer's work
"
It seems that some efficiency is low, but it is actually just the opposite. Studies have shown that the programming will get better code for programmers to work alone. This proves: The two minds are more than a better than one!
Many programmers oppose pair of programming without trying. This really requires some practices to do it, and you need to practice more than a few weeks more. 90% of learning have become a programmer of programming, so we highly recommend it to all the teams.
In addition to providing better code and testing, the team also provides knowledge in the middle of the team. When the partner is exchanged as a pair of programmers, everyone will learn new knowledge from other people. Programmers are studying, their technology is raising, and they become more valuable to teams and companies. Being pair, even if it itself is
XP
Being external to the process is also a huge success of everyone.
Test priority development
Extreme programming around feedback, in software development, good feedback requires a good test. the best
XP
Team practice
"
Test priority development
"
Add a test in a small loop and let it work. Almost easily, the code provided by the team is close to
100%
There are test programs cover, in most cases this is very important. (If your programmer has provided more existing test programs, you will have more power. Save them, they will only provide help!)
It is still not enough to write only test programs: you have to run them. Here, extreme programming is also extreme. These ones
"
Programmer test
"
,Or
"
unit test
"
It is a complete collection that whenever the programmer issues any code to the code library (the paired programmer usually releases twice or more), each programmer test must be able to run correctly. Every time is 100% run! This means that programmers can get feedback on how they do what they do. Further, these tests provide invalvation support when software design improvements.
Design improvement
Extreme programming is focused on providing business value in every iteration. In order to complete this goal throughout the project, the software system must have a good design. Oblective may decrease and eventually stagnate. therefore
XP
Using a process of continuous improvement design, called
"
Reconstruct
"
,From
Martin Fowler
Title,
"
Refactoring: Improve the design of existing code
"
.
Reconstructing process is concerned with repetition (a clear sign of a poor design) and improve the code
"
Consolidation
"
And reduced
"
coupling
"
. High-intensity and low coupling have been recognized as a good design in the last thirty years. The result is
XP
The team starts from a good and simple design and always makes the software system have a good simple design. This allows them to maintain their development speed and usually improve project development speeds.
Reconstruction is naturally a strong support by comprehensive testing, these tests are used to confirm that there will be no destruction in the system when design changes. Therefore, customer testing and programmers test are effective evaluation factors.
XP
Practice is supportive: they will be more strong than their own independence.
Continuous integration
Extreme programming team always keeps the system completely integrated together. We say that the daily constructing version is provided for the weak:
XP
The team must build the system many times a day. (One
40
Human
XP
The team integrates at least eight to ten times a day! )
The benefits of this practice can be understood by recalling the item you may have heard (or personally involved) project: When the system is constructed, it is usually fell into every week or at a lower frequency.
"
Integrated hell
"
Everything is not running there and no one knows why.
Less integration will bring a range of questions to the software project. The first, although integration is the condition of the issued work code,
But the team does not practice it, and usually it is delegated to people who don't know much about the entire system. Second, very few integrated code is usually
-
I would rather say that
-
Maxi leaks.
Collective code ownership
In an extreme programming project, each pair of programmers can improve any code at any time. This means that all code gain more benefits under many people's concerns, so that code quality and reduces defects. There is another important benefit: When the code is only responsible for a single person, the required characteristics tend to put a wrong location because a programmer finds that he needs a feature but that code is not managed. The owner of the code is too busy and cannot add this feature, so this programmer has to add this feature to his own code that should not exist. This leads to ugly, difficult to maintain to the code, full of repeating and low (poor).
If someone makes blind modifications on the code they don't understand, the collective code ownership may bring problems.
XP
Through two key technologies to avoid such problems: Capture errors via programmers, deal with programming, indicating that the best way is to find an expert in this area as a partner when working on unfamiliar code. In order to ensure good modifications in need, this practice extends to the entire team.
Coding standard
XP
The team follows a public coding standard, so all the code in the system looks like a single
-
Very powerful
-
Hand of people. This standard is not important: It is important to let all the code look very similar to support the collective code ownership.
System metaphor
Extreme programming team has formed a consensus for the program, we call it
"
System metaphor
"
. At the optimum state, the system is compared to a simple soul description of how the program works, for example
"
This program is like a box of bees, looking for pollen and bringing back to the beehive.
"
As a description of an agent-based information query system.
Sometimes a very poetic imagination may not appear. In any case, no matter whether there is no vivid metaphor,
XP
The team will use a public naming system to ensure that everyone can understand how the system works, and where to find the features you need, or find the correct position you want to add functionality.
Acceptable pace
Extreme programming teams will take a long time here. They work hard and under a pace of continuous maintenance. This means that they work overtime when they are effective, and they often work to ensure that there is the greatest productivity every week. This properly explaining the death competition project neither productivity does not create a quality software system.
XP
The team is here to win rather than die.
summary
Extreme programming is a development discipline based on simplicity, communication, feedback, and courage. Its practice is to closely link the entire team with a valid practice rule. Through full feedback, the team can always know your current situation and properly adjust the practice rules to adapt to your special circumstances.
