顥?顥?extreme Programming (eXtreme Programming) is a development of discipline, simplicity, communication, feedback and courage as the basic aim. Its approach is practical and effective rules for the whole team closer together, through adequate feedback to enable the team to keep aware of their current situation and the proper regulation of the rules to suit their particular circumstances.
顥?顥?In Extreme Programming, every contributor is a project "team" full part. This team was built around a team every day and sit together to work together with business representatives - the "Client" set up.
顥?顥?core practice: the whole team
顥?顥?Extreme Programming teams use a simple approach to planning and tracking to determine what to do next and to predict when the project will be completed. Focus on business value, the team passed through a series of customer-defined test and fully integrated to create small software publishers.
顥?顥?core practice: planning strategies, small releases, customer test
顥?顥?extreme programmers the way through paired and group work together, through simple design and compulsory testing of code, constantly improve the design to ensure the design is always appropriate to the current needs.
顥?顥?core practices: simple design, pair programming, test-first development, design improvements
顥?顥?Extreme Programming team will always maintain a system to integrate and run all the time. The way programmers write in pairs all the product code, and have to work all the time. They form a similar code to ensure that all members can be required to understand and improve all the code.
顥?顥?core practice: continuous integration, collective code ownership, coding standards
顥?顥?Extreme Programming team shares a simple system of public and blueprint. All members can keep up from time to time in accordance with a kind of rhythm work.
顥?顥?core practice: the system metaphor, an acceptable pace
顥?顥?team as a whole
顥?顥?an XP project all participants as a team member sit together. The team must include a representative of the business - "customers" needs him to set the priority degree and the direction in charge of the entire project. Best to the client or his assistant is an end-user to understand the field, know what is needed. Team, of course, there are programmers. Team may include testers, who help customers define customer acceptance testing. Analysts as customer assistant, to help customers define requirements. Usually there will be a guide, he helped the team to track, promote the development process. There may be a manager, he provides resources to deal with foreign exchanges and the division of work. None of these duties must be unique to an individual: each of XP team members in any way they can do to participate, the best team no experts, only a few have special skills to participate in general persons.
顥?顥?XP software development projects to solve two key problems: the responsibility to predict what things will be completed during the period, and determine what needs to be done next. Grasp of the project focused on the right track - it is quite straightforward - more than hope that something will need to accurately predict which and how much time possible - this is very difficult. In XP there are two key planning steps to solve these two problems:
顥?顥?release plan is a practical demonstration programmers allow customers to obtain the desired characteristics, and programmers to assess their degree of difficulty. When the hand with the cost of assessment and the importance of these characteristics of cognitive processes, the customer to arrange a project plan. The initial release plan need to leave enough room for: priority and the assessment are not real reliable, and know the team before starting work, we can not exactly understand the progress of the development team. Even the initial release plan is not precise enough to be decisive, so XP teams often released from time to time correction program.
顥?顥?iteration plan is to take a practice for the development team a few weeks every direction. XP teams through two weeks of "iteration" to create a software system, the end of each iteration can be run to provide the practical use of software systems. During iteration plans, customer presentations within the next two weeks hope to complete features. Programmers to separate them into several tasks, and to assess their cost (up plans to release detailed some). Based on the previous iteration to complete the work, the team signed the current iteration of work will have to bear.
顥?顥?These plans are very simple, but they offer very good information and excellent steering control. Every few weeks, how much progress can be at a glance. In XP, there is no "90% complete": a feature story either completed or not completed. Concerned about the visual result is a nice little way of opposing arguments: on the one hand, the very intuitive, if progress is not satisfactory, the customer can cancel the project in a particular location. On the other hand, progress is obvious to, and determine the capacity of those things that will be completed very well, so XP projects are often less able to do more under the pressure of need.
顥?顥?characteristics as required by each part of the demonstration, XP Customer defines one or more automated acceptance tests to indicate that the property has been able to achieve. Team to achieve these tests and use them to prove to themselves and their clients features have been correctly implemented. Due to time pressures, automation is very important, manual tests will be skipped. It's like when the night comes, you can turn off your lights.
顥?顥?best XP team will test their customers the same treatment as a programmer tests: once the test run, and ever since has been the team will maintain its ability to run correctly. This means that systems can only be improved, always forward, from not be reversed.
顥?顥?XP teams practice through two important ways a small release:
顥?顥?first, the team released in each iteration can be run, tested the software system to provide customer choice of commercial value. Customers can use this software for any purpose system is to assess whether or distributed to end users (highly recommended). The most important way to the end of each iteration when the software is visible, and submit to the customer. This ensures that all things are open and real.
顥?顥?Second, XP teams release as often as possible to their end users. XP Web projects to publish every day, home projects are published monthly or more frequently. Even simple products can be packaged to ship every quarter.
顥?顥?so often seem to create a good version may not likely, but XP teams all the time during the release. More information can see continuous integration, and note that the frequent release of these can be seen everywhere through the XP test (as customers test and test-first development described) becomes reality.
顥?顥?XP teams build software for a simple design. They start simple, and programmers in the testing and design improvements throughout the process, they kept the design simple. An XP team is always just keep the design functional requirements for the system current. There is no extra input, and software systems for the future is always ready.
顥?顥?In XP, the completion of the design is not a one-time thing, not a top-down thing, it is a matter from beginning to end. In the release planning and iterative design steps are planned in the rapid design process and set the capacity of the team throughout the project to improve the structure of the design. This is similar to extreme programming in an incremental and iterative process, good design is essential. This is the whole development process must be more attention to design reasons.
顥?顥?all the products in the XP software is composed of two programmers sit side by side, in the same machine together completed. This practice ensures that all the product code has at least one of the other programmers were examined, and the result is better design, better testing and better code.
顥?顥?two programmers to do "a programmer's work" may seem a little inefficient, but in fact just the opposite. Studies show that the pair programming to programmers working alone in the same period of time will be better code. This shows that: two minds together much better than the one!
顥?顥?many programmers have not yet tried the case against the pair on the program. It does take some practice to do it, and you need to seriously practice a few weeks time to see results. 90% of the studied pair programming, programmers will like it, so we strongly recommend to all the teams it.
顥?顥?Aside from providing better code and tests, the team also provided into the knowledge transfer among the team. Exchange partners as a programmer on the ground, each person will someone from the other learned new knowledge. Programmers in learning, improving their technology, in terms of their team and the company becomes more valuable. Pairs, even if it outside of the implementation process in XP is a great success for everyone.
顥?顥?feedback around extreme programming, and in software development, good feedback requires good testing. The best XP team practice "test-first development", in a small increase in a test cycle, then it can work. Almost easy, the code team has a test program is nearly 100% covered, in most cases this is a very important step forward. (If your programmers have provided more existing test procedure, you will have more power. Will they survive, they will provide help!)
顥?顥?just wrote a test program is not enough: you have to run them. Here, Extreme Programming is extreme. These "programmer tests", or "unit testing" is a complete set, when programmers publish any code to the code base of the time (paired programmers are usually published twice or more times a day), Every programmer tests must run correctly. Are 100 percent all the time to run! This means that programmers can immediately be done about how their feedback. Furthermore, these tests provide invaluable software design support for improvement.
顥?顥?extreme programming in each iteration are focused on providing business value. In the course of the project in order to complete this goal, the software system must have a good design. Selectivity may be reduced and ultimately stagnation. So XP uses a process of continuous improvement design, called "reconstruction", the title comes from Martin Fowler, "Reconstruction: Improving the design of existing code."
顥?顥?concerned about the reconstruction process of removing duplicate (a clear sign of poor design), and to improve code "cohesion", as well as reduce the "coupling." High cohesion and low coupling in the last three decades been recognized as good design features. The result is that XP teams simple design from a good start, and always let the software system has a good simple design. This allows them to maintain their development speed, and often in practice to improve the speed of project development.
顥?顥?reconstruction is of course through comprehensive testing to provide strong support, these tests used to identify the time when the design changes will not damage anything in the system. The customer tests and programmer tests are a valid assessment of factors. XP is the practice of mutual support: they will be more robust than their independence.
顥?顥?Extreme Programming team is always to keep the system fully integrated. We say that a daily build version is available for the weak: XP teams build the system many times every day. (A 40-person XP team integrates at least daily from 8 to 10 times!)
顥?顥?benefits of this practice can recall you may have heard of (or is personally involved in) projects to understand: When the system is built every week or when a lower frequency, usually into "integration hell" , where all things can not run and no one knows why.
顥?顥?little software project will bring to integrate a range of issues. First, although integration is the issue of good working conditions for the code, but the team is not to practice it, and often it is delegated to those who do not quite understand the whole system of people. Second, very few integrated code is often - I always prefer to say - flawed.
顥?顥?collective code ownership
顥?顥?In an extreme programming project, each pair of programmers can improve at any time any one of the code. This means that all the code in many people's attention more under the revenue code that enhance the quality and reduce defects. There is another important benefit: When the code is only by a single individual responsible for the time required features are often placed in the wrong place, because a programmer discovered that he needs a feature, but that code does not return his management.浠ｇ爜鐨勬墍鏈夎?澶繖涔愯?涓嶈兘鍘诲鍔犺繖涓壒鎬э紝鎵?互杩欎釜绋嬪簭鍛樺彧濂芥妸杩欎釜鐗规?鍔犺繘浜嗚繖涓壒鎬ф湰涓嶅簲璇ュ瓨鍦ㄧ殑浠栬嚜宸辩殑浠ｇ爜涓?杩欏鑷翠簡闅剧湅鐨勶紝闅句簬缁存姢鍒颁唬鐮侊紝鍏呮枼鐫?噸澶嶅拰浣庯紙宸級鐨勫唴鑱氥?
FLV To PSP
OGM TO MP4
Drake ringtones over ringtone by drake
OGM to MKV