Concept

Goals

Extreme Programming Explained describes Acute Programming as a software development conduct that organizes humans to aftermath college superior software added productively.

XP attempts to abate the amount of changes in requirements by accepting assorted abbreviate development cycles, rather than a continued one. In this article changes are a natural, assured and adorable aspect of software development projects, and should be planned for instead of attempting to ascertain a abiding set of requirements.

Extreme programming aswell introduces a amount of basal values, attempt and practices on top of the active programming framework.

editActivities

XP describes four basal activities that are performed aural the software development process: coding, testing, listening, and designing. Each of those activities is declared below.

editCoding

The advocates of XP altercate that the alone absolutely important artefact of the arrangement development activity is cipher – software instructions a computer can interpret. Afterwards code, there is no alive product.

Coding can aswell be acclimated to amount out the a lot of acceptable solution. Coding can aswell advice to acquaint thoughts about programming problems. A programmer ambidextrous with a circuitous programming botheration and award it harder to explain the band-aid to adolescent programmers ability cipher it and use the cipher to authenticate what he or she means. Code, say the proponents of this position, is consistently bright and abridged and cannot be interpreted in added than one way. Added programmers can accord acknowledgment on this cipher by aswell coding their thoughts.

editTesting

Extreme programming's access is that if a little testing can annihilate a few flaws, a lot of testing can annihilate abounding added flaws.

Unit tests actuate whether a accustomed affection works as intended. A programmer writes as abounding automatic tests as they can anticipate of that ability "break" the code; if all tests run successfully, again the coding is complete. Every section of cipher that is accounting is activated afore affective on to the next feature.

Acceptance tests verify that the requirements as accepted by the programmers amuse the customer's absolute requirements. These activity in the analysis appearance of absolution planning.

A "testathon" is an accident if programmers accommodated to do collaborative analysis writing, a affectionate of brainstorming about to software testing.

editListening

Programmers accept to accept to what the barter charge the arrangement to do, what "business logic" is needed. They accept to accept these needs able-bodied abundant to accord the chump acknowledgment about the abstruse aspects of how the botheration ability be solved, or cannot be solved. Advice amid the chump and programmer is added addressed in the Planning Game.

editDesigning

From the point of appearance of simplicity, of advance one could say that arrangement development doesn't charge added than coding, testing and listening. If those activities are performed well, the aftereffect should consistently be a arrangement that works. In practice, this will not work. One can arise a continued way afterwards designing but at a accustomed time one will get stuck. The arrangement becomes too circuitous and the dependencies aural the arrangement cease to be clear. One can abstain this by creating a architecture anatomy that organizes the argumentation in the system. Good architecture will abstain lots of dependencies aural a system; this agency that alteration one allotment of the arrangement will not affect added locations of the system.citation needed

editValues

Extreme Programming initially accustomed four ethics in 1999. A new amount was added in the additional copy of Acute Programming Explained. The 5 ethics are:

editCommunication

Building software systems requires communicating arrangement requirements to the developers of the system. In academic software development methodologies, this assignment is able through documentation. Acute programming techniques can be beheld as methods for rapidly architecture and disseminating institutional ability a allotment of associates of a development team. The ambition is to accord all developers a aggregate appearance of the arrangement which matches the appearance captivated by the users of the system. To this end, acute programming favors simple designs, accepted metaphors, accord of users and programmers, common exact communication, and feedback.

editSimplicity

Extreme programming encourages starting with the simplest solution. Extra functionality can again be added later. The aberration amid this access and added accepted arrangement development methods is the focus on designing and coding for the needs of today instead of those of tomorrow, next week, or next month. This is sometimes summed up as the "you ain't gonna charge it" (YAGNI) approach.9 Proponents of XP accede the disadvantage that this can sometimes entail added accomplishment tomorrow to change the system; their affirmation is that this is added than compensated for by the advantage of not advance in accessible approaching requirements that ability change afore they become relevant. Coding and designing for ambiguous approaching requirements implies the accident of spending assets on something that ability not be needed. Accompanying to the "communication" value, artlessness in architecture and coding should advance the superior of communication. A simple architecture with actual simple cipher could be calmly accepted by a lot of programmers in the team.

editFeedback

Within acute programming, acknowledgment relates to altered ambit of the arrangement development:

Feedback from the system: by autograph assemblage tests,5 or active alternate affiliation tests, the programmers accept absolute acknowledgment from the accompaniment of the arrangement afterwards implementing changes.

Feedback from the customer: The anatomic tests (aka accepting tests) are accounting by the chump and the testers. They will get accurate acknowledgment about the accepted accompaniment of their system. This analysis is planned already in every two or three weeks so the chump can calmly beacon the development.

Feedback from the team: If barter arise up with new requirements in the planning bold the aggregation anon gives an admiration of the time that it will yield to implement.

Feedback is carefully accompanying to advice and simplicity. Flaws in the arrangement are calmly announced by autograph a assemblage analysis that proves a assertive section of cipher will break. The absolute acknowledgment from the arrangement tells programmers to recode this part. A chump is able to analysis the arrangement periodically according to the anatomic requirements, accepted as user stories.5 To adduce Kent Beck, "Optimism is an anatomic hazard of programming. Acknowledgment is the treatment." 10

editCourage

Several practices actualize courage. One is the bidding to consistently architecture and cipher for today and not for tomorrow. This is an accomplishment to abstain accepting bogged down in architecture and acute a lot of accomplishment to apparatus annihilation else. Adventuresomeness enables developers to feel adequate with refactoring their cipher if necessary.5 This agency reviewing the absolute arrangement and modifying it so that approaching changes can be implemented added easily. Another archetype of adventuresomeness is alive if to bandy cipher away: adventuresomeness to abolish antecedent cipher that is obsolete, no amount how abundant accomplishment was acclimated to actualize that antecedent code. Also, adventuresomeness agency persistence: A programmer ability be ashore on a circuitous botheration for an absolute day, again breach the botheration bound the next day, if alone they are persistent.

editRespect

The account amount includes account for others as able-bodied as self-respect. Programmers should never accomplish changes that breach compilation, that accomplish absolute unit-tests fail, or that contrarily adjournment the plan of their peers. Associates account their own plan by consistently appetite for top superior and gluttonous for the best architecture for the band-aid at duke through refactoring.

Adopting the four beforehand ethics leads to account acquired from others in the team. Nobody on the aggregation should feel unappreciated or ignored. This ensures a top akin of activity and encourages adherence adjoin the aggregation and adjoin the ambition of the project. This amount is actual abased aloft the added values, and is actual abundant aggressive adjoin humans in a team.

editRules

The aboriginal adaptation of rules for XP was arise in 1999 by Don Wells11 at the XP website. 29 rules are accustomed in the categories of planning, managing, designing, coding, and testing. Planning, managing and designing are alleged out absolutely to adverse claims that XP doesn't abutment those activities.

Another adaptation of XP rules was proposed by Ken Auer12 in XP/Agile Universe 2003. He acquainted XP was authentic by its rules, not its practices (which are accountable to added aberration and ambiguity). He authentic two categories: "Rules of Engagement" which behest the ambiance in which software development can yield abode effectively, and "Rules of Play" which ascertain the minute-by-minute activities and rules aural the framework of the Rules of Engagement.

editPrinciples

The attempt that anatomy the base of XP are based on the ethics just declared and are advised to advance decisions in a arrangement development project. The attempt are advised to be added accurate than the ethics and added calmly translated to advice in a applied situation.

editFeedback

Extreme programming sees acknowledgment as a lot of advantageous if it is done rapidly and expresses that the time amid an activity and its acknowledgment is analytical to acquirements and authoritative changes. Unlike acceptable arrangement development methods, acquaintance with the chump occurs in added common iterations. The chump has bright acumen into the arrangement that is getting developed. He or she can accord acknowledgment and beacon the development as needed.

Unit tests aswell accord to the accelerated acknowledgment principle. If autograph code, the assemblage analysis provides absolute acknowledgment as to how the arrangement reacts to the changes one has made. If, for instance, the changes affect a allocation of the arrangement that is not in the ambit of the programmer who fabricated them, that programmer will not apprehension the flaw. There is a ample adventitious that this bug will arise if the arrangement is in production.

editAssuming simplicity

This is about alleviative every botheration as if its band-aid were "extremely simple". Acceptable arrangement development methods say to plan for the approaching and to cipher for reusability. Acute programming rejects these ideas.

The advocates of acute programming say that authoritative big changes all at already does not work. Acute programming applies incremental changes: for example, a arrangement ability accept baby releases every three weeks. If abounding little accomplish are made, the chump has added ascendancy over the development activity and the arrangement that is getting developed.

editEmbracing change

The assumption of all-embracing change is about not alive adjoin changes but all-embracing them. For instance, if at one of the accepted affairs it appears that the customer's requirements accept afflicted dramatically, programmers are to embrace this and plan the new requirements for the next iteration.