Extreme programming and agile development
Author: Xu Jing Zhou
After reviewing the life cycle of software development in accordance with my understanding, I got a conclusion that the only software document that meets the engineering design standard is the source code list.
- Jack Reeves
Introduction In 2001, in order to solve many companies' software teams to fall into the rushing process, a group of industry experts summarize some values and principles that allow the software development team to have fast work, respond to change capabilities, they call themselves for agile alliance . Amgegility development process is a lot, mainly: Scrum, Crystal, Feature Drive Software Development (FDD), Adaptive Software Development, ASD, and the most important limit programming, Abbreviation XP). Extreme Programming (XP) was first advocated by the Master Character Kent Beck in the SmallTalk community in 1998.
Extreme programming design and programming are people's activities. Forget this, you will lose everything.
- Bjarne Stroustrup
Extreme Programming (XP) is the most famous one in agile method. It consists of a series of simple but-dependent practice. These practices are combined together to form a whole. Here is an effective practice of extreme programming:
All participants of the full team XP project (developers, customers, testers, etc.) work together in an open place, they are members of the same team. The walls of this place are randomly hanging on a large, significant chart, and some other things that show their progress. The planning game plan is continuous, step by step. Every 2 weeks, the developer will estimate the cost of the candidate characteristics in the next 2 weeks, while the customer selects the characteristics you want to achieve based on cost and business value. Customer testing as part of each desired feature, customers can define auto acceptance tests based on scripting languages to indicate that this feature works. Simple design team maintains design just matches the current system function. It passes all the tests, does not contain any repetition, expressing all the writers want to express, and contain as little code as possible. Ending all product software is built from two programmers and placed on the same machine and placed on the same machine. Test-driven development writing unit test is a verification behavior, a design behavior. Similarly, it is a behavior of writing documents. Write unit tests Avoid a considerable number of feedback cycles, especially feedback cycles in software functionality. The programmer works in a very short cycle period, they first add a failure test and pass it. The improvement design is used to improve the corrupt code at any time, keep the code as clean and expressive. The continuous integration team always integrates the system completely. After a person is dismantled (Check IN), other owner's liability code is integrated. The collective code ownership can improve any code at any time at any time. No programmers are responsible for any particular module or technology, each can participate in any other development. All the code in the code standard system seems to be written by one person alone. Metaphors link throughout the system together; it is a future image of the system, which makes it makes the location and appearance of all individual modules. If the appearance of the module does not match the entire metaphor, then you know that the module is wrong. The sustainable speed team only has a wins hope. They work hard to work for a long time, they save energy, they see the project as a marathon, not full speed. Extreme programming is a simple, specific practice, which combines these practices to form an agile development process. Extreme programming is an excellent, universal software development method, project team can use directly, or add some practices, or to modify some of them.
The interaction between agile developers is complicated and its effect is difficult to expect, but it is the most important aspect of work. - Tom Demacro and Timothy Lister
Agile Software Development Declaration:
Individuals and interactions overhead the process and tools that can work better than the face-oriented document customer cooperation is better than the contract negotiations
Although the right item is also valuable, we think the left item has greater value.
We must make customers satisfied with the early, sustained delivery of valuable software. Even later, it is also welcome to change demand. Agile process uses changes to create competitive advantages for customers. Software that is often delivered, the interval delivered can be delivered from several weeks to a few months, the shorter the time interval delivered, the better. During the development of the entire project, business people and developers must work together every day. Build a project around an individual that is embraced. Give them the required environment and support and trust them to complete the work. Inside the team, the most effectively transmitted information is the face-to-face conversation. Working software is the primary schedule metric. Agile process advocates sustainable development speed. Responsible persons, developers and users should be able to maintain a long-term, constant development speed. Continuously pay attention to excellent skills and good designs will enhance agility. Simple is the most fundamental. The best architecture, demand and design are from the self-organizing team. Every time, the team will make an anti-provision in how to work more effectively and then adjust their behavior accordingly.
When the software development is changed, the software design will have a bad way. When any of the smells appear in the software, it indicates that the software is corrupt.
Relinex: It is difficult to change the system because each change will force many other changes to the rest of the system. Vulnerability: The change of the system will cause problems in many places in the system and changes in the system. Solidity: It is difficult to unlock the system's entanglement, making it some components that can be used in other systems. Adhesive: Doing the right thing is difficult than doing mistakes. Unnecessary complexity: The design contains the infrastructure that does not have any direct benefits. Unnecessary repetition: The design contains repetitive structures, and the repeated structure can be unified using a single abstraction. Hiking: It is difficult to read, understand. Not well expressed.
The agile team relies on changes to get vitality. The team is hardly designed, so there is no need for a mature initial design. They are more willing to maintain design as clean, simple, and use many unit tests and acceptance tests. This maintains the flexibility of design and is easy to understand. The team uses this flexibility, continuously improves the design so that the system each iterative ends is most suitable for the designs of the iteration. In order to change the corrodation flavor in the above software design, agile development has taken the following face-to-object design principles to avoid, these principles are as follows:
Single Responsibility Principles (SRP) should have only one reason why it causes it. Open-Closed Principles (OCP) software entities should be extended, but they cannot be modified. The Liskov Replacement Principle (LSP) subtype must be able to replace their base type. Dependency Invert Principles (DIP) abstraction should not depend on the details. Details should depend on abstraction. Interface Isolation Principles (ISP) should not force customers to rely on how they don't need. The interface belongs to the customer and does not belong to the class hierarchy. The granularity of the reuse of the release equivalence (REP) is the particle size released. All classes in the commonly closed principle (CCP) package should be commonly closed for changes in the same type of nature. A variation will have an impact on a package, which will have an impact on all classes in the package, and no impact on other packets. All classes in a package should be commonly reused in principle (CRP). If you reuse a class in the package, you have to reusable all classes in the package. The ringless dependent principle (ADP) does not allow the existence ring in the rely of the package. The Stable Dependence (SDP) is dependent on a stable direction. The abstraction of the stable abstract principle (SAP) package should be consistent with its stability. The concept of the above package is that the package can be used as a container that is inclusive, by organizing the class, we can understand the design on a higher level abstraction, we can also manage software development and release . The purpose is to divide the class in the application based on some principles, and then assign those classified classes to the package. The following is an example of a simple design problem model and the principle application: Problem: Select the software to run in the simple barlight, the table lamp consists of a switch and a lamp. You can ask the switch to open or close, you can also turn the light open or close. Solution 1: Next, FIG. 1 is a simplest solution that switch objects can poll the status of the real switch, and can send the corresponding Turnon and Turnoff messages to Light. Solution 2: The above design violates two design principles: Dependency Imperial Principles (DIP) and Open Closed Principles (OCP), DIP principles tell us to depends on abstract classes, while Switch rely on specific class Light, for OCP Violation is to bring Light on any place where Switch is needed, so you can't easily extend SWITCH to manage other objects outside Light. In order to solve this solution, an interface can be used in the Abstract Server mode, which enters an interface between Switch and Light, which allows Switch to control anything that implements this interface, which also meets the DIP and OCP principles. As shown in Figure 2: Solution 3: The solution shown above, violates a single responsibility principle (SRP), which binds Switch and Light, and they may change due to different reasons. This problem can be solved by Adapter mode. The adapter is derived from switchable and delegates to light. The problem is solved, and now Switch can control any objects that can be turned on or off. But this also needs to be exchanged for time and space. As shown in Figure 3 below: Agility design is a process, not an event. It is a process of continuous application principles, patterns, and practices to improve the structure and readability of the software. It is dedicated to maintaining system design as simple, clean and featured.
references
Design mode - can be used for object-oriented software basic - Li Yingjun and other translation rendering - improve the design of existing code - Houjie and other translations - principles, model and realization - Deng Hui translated
Contact information
Email: Jingzhou_xu@163.com Future Studio (FUTURE Studio)
