How to become XP customers
Roy W. Miller (Source IBM DeveloperWorks) August 19, 2004
What does it mean by the driver software?
XP requires a profound transformation of business personnel. In the past 30 years, software development methods have enabled companies to think and act in some ways. Unfortunately, traditional methods are wrong because they don't always produce these people's desired results: Software that meets their needs at the end of the project, with software that is longer and timely delivery.
The discussion is a very demanding requirement. Regrettably, traditional software development is always delivered in time. One of the main reasons may not be thinking about it at all: Customers have not made their work. Before I do, you need to understand what features of the "customer" of the XP project.
Can't you realize?
XP describes a beautiful situation. Customer (or a consistent group of people) telling the programmer what kind of software prepared. The customer identifies some feature and gives why this is a necessary reason. Ideally, customers will quantize this feature - what is its minimum requirement? Although a quantitative characteristic is not always possible, it is always worth a try. If it is impossible, don't let this stop you from producing excellent software, but don't assume that it is never possible. Try it.
The software should be driven by business needs, but the usual situation is the technical personnel leadership project. They build things they want to build, which is usually because customers are leaving their duties when the project is at the beginning, or programmers give up on some moments. Why is this this? History of software development has made all participating people to think and act in some ways. In the case of too many, the result is disappointment, distress and setbacks.
Deepen in Taylor
Frederick W. Taylor in the 1980s is a long working manager, and he has been studying the factory in the process of more than 30 years. He notes a most important feature: inefficient. He began to eliminate inefficientness of "unique best ways" to find any work, and how to find the best way to find the best way to find the best way for each of them. By the 1950s, Taylorism was the main management philosophy. The company's software development was debut in that decade, and people who managed their business made a seemingly good assumption. They assume the same management principles for other production types - considering the same way - also applies to software.
Consider the car assembly line. Parts and raw materials come in from this head and assembled the car from another. What you don't want to see is: Everyone on the assembly line gather together to decide to change bicycles. There is no chance to create on the assembly line. You really want is a predictability - you want to assemble the wiring every time you run. In this area, the problem is always the same as the solution, and you can effectively optimize the process. Of course, once you optimize things and make it smoothly, then "change" has become enemies. Even if the environment is dynamic at the bottom, people will make it foreseeable.
This model of "efficiency" is not suitable for software. For software, the problem is always different. It may be similar to what you have seen before, but it is never the same. This means that the solution cannot be the same. It is impossible to follow the manual to get the correct answer. If the problem is different and the solution is different, you don't have to consider optimization. It does not exist at all. Change is constant.
To a certain extent, you can say that the software development team (for internal or external users) is trapped in the way of assembling the line. Taylor made a deep imprint to the corporate culture. People who act as software project customers are usually managed by the user group, or itself is the user. If they manage users, they are managers. If they are themselves, they are in an environment that is controlled by the manager. Either case, assembly line thinking is standard.
Business people who participated in software development have begun to believe that their roles are mainly front-end: they specify a detailed and unchanging demand for programmers in the early days of the development cycle, then stop waiting. Of course, they should have the right to control the process. After all, they are working hard, they are providing demand, and the completed products must make them satisfied. But the business is very small. The skilled person will soon tell the business person software to be "soft", but these technicians have boycott changes because the change is painful and cost. The programmer does not wish to release it without the software, and the business person does not want the new software to cause too much damage to the user, so the two sides will make the issuance not timely - sometimes released after the project starts. At the end of this cycle, the ultimately obtained software is not the software needed - it is that the company thinks it needs at the beginning of the project. Most customers are not interested in buying such a "age" software, but this is what they get. The technicians don't want to deliver such software, but they think they don't have a choice. Everyone feels frustrated, tired, anger and being deceived.
Everyone participating in the creation software is compromised in some of the processes. Perhaps it is to keep the rice bowl or minimize conflict. Perhaps because of your docking theory, you have affected you in the case of you without awareness. Perhaps because it is lazy. No matter what, everyone has done a bad decision. Everyone feels that it is good to keep the current situation. Unfortunately, only changes can make things better. We need to go back to that road. One of the best places to start is customer behavior.
Learn to drive
Software development has been very consistent in the past thirty years. Of course, there have been some improvements in the development process, but the basic theme is the same:
Users don't really know what they want, so developers must tell them to produce software.
Change is harmful, so we should prohibit it at all costs.
The way to change the change is to write all things on paper at the very beginning, find some people signed the approval, and then perform it as this plan.
The only way to define all the needs in turn is to make the business to make a set of needs, and the products completed at the end trial to confirm that each matter is consistent with these needs, while in the medium term.
The result is that most software project production (if they do produce some things), someone thinks what he wants at the beginning, rather than software users finally wanted at the end. What we finally get is something we don't want, but it seems that there is no way to go out of this strange circle. Managers cannot just regulate changes. This has never played in the past, and it will not be in the future. Why are we going to be embarrassed, what should we do?
First, people who are XP customers need to play a role. Can people become a customer? Usually people with enough domains and end user knowledge, people who can make difficulties in feature. He may be a super user who knows the user's truly need. He may be a market sales personnel to understand market demand and competitors. He generally won't be a manager who got this position, although this may always be better than customers. Some people must accept the position and promise to do this.
Second, anyone who accepts the customer position must take himself as a team of the team. He must be willing to spend the necessary time and other members of the team to produce the right software. Customers cannot pre-depart, if the software fails, relying on the push tricks that are difficult to self-contained, they will cover themselves. Customers can't ask him to ask him to leave him to ask him to barely agree. He is not in making trouble; he is in the direction of the team.
Third, the customer must temporarily put the suspicion, try to express it as if the method of exploring the production of the production of the product is better than the pre-provision each matter. This is difficult for programmers and customers. The programmer hopes that every step of the way can produce excellent software. They think that everything will be described in advance and not departing from the specification to ensure this. Customers are also worried. They want to write into every possible demand (including what they don't really need), so that there is more room for yourself for yourself when you have to give up. These views have no excellent software that helps team production. Customers need to explain what software truly needs, what is the most important. Then they must believe that the programmer (yes, it is difficult to do one) will continue to work tirelessly toward the goal. Of course, programmers must win more trust through words. This is risky for everyone, but is a typical way to do things. Using XP, risk is obvious, not hidden by the piles of paper and commitments. Fourth, customers must change their way they consider software. How can I know what software really needs? I only know two ways: guess and count on guess, or pay the software at a point in order to better understand the truly need of the customer. Flowering a lot of time to discuss the software they need and the software is only the first method of the first method. People are people. Let them use the computer to change this. The only way to really understand demand is to have an example of running. Both team members can use it to find common: "Here, see this? That is not what I want. The position of that thing is really bad It is a lot to pass, it can be better there. But this, this is really great. "Feedback is very important, so the team should have early post feedback. Sitting Software has become "perfect" will only post you guess the bad news.
If this is all, what is the problem? Things are not so simple. In fact, it is too difficult, so that most people are reluctant to do it. Even if they are willing to do, they can't do it. Most organizations do not allow such a process when it is created. Using XP production software will encounter powerful boycots because some rights are not intelligent for orthodoxicity - and because some of the right people are stubborn.
Organization may become a problem
If the organization where the XP client does not agree to use XP, he can't do his work. This means two things:
There must be an XP team to include the customer.
The customer's boss must make our customers a part of the team.
The team must use XP before you can do his work. If the team is pretending to use XP, or restrict the ability to act as the role, XP will not work. Unfortunately, most organizations have an opposite, such alignment or conscious or naturally formed. Unless there is at least a small part of the organization to try XP, it will not work. But you can do it from small. A customer, several developers and a small app are all you need. If the team produces excellent products, it is possible that other teams will take some behavior.
If the XP team needs a certain customer, and the expected customer's boss does not allow him to spend any time in the team, what will it? In that case, this project is destined to fail from the beginning. If the team needs customers to participate in the plan or try the latest app, but the customer is always busy filling the A-324-XYZ report to cope with the upcoming annual situation, then the team will not deliver their commitment. s things. Without a similar domain expert, you cannot study effectively, and the expert is the customer. People who control the customer time in the organization must give up some requirements.
The establishment of most organizations makes this almost impossible. So, will we always be embarrassed? Maybe, but I don't think we have to do this. Changing this situation requires courage.
Change the courage
Frankly, I think there are three reasons to promote the company's IT staff can't fall into this strange circle habit.
cowardly
Lack of vision
It is difficult to break the habits. You have not even considered this. The habit is a natural part of your life, even if you are awake, you know that you should not act. That's why people smoke, eating or yelling at their children. Once you have some habits, break it requires conscious efforts. Most of the company's production software is directly from the habits of members of the company.
Many of the companies have no courage. The matter is truly trouble, and they truly realize that the organization will move to the wrong direction, they either succumb to people. At this moment, if you stay in a certain organization is really bad, and you don't have the biggest effort, you can't improve it, it may be the time when you leave, for this situation, I will be the first to agree. But when you see the resistance, you don't have a solution. You are escaping the inevitability. You ran to another place, where similar questions suddenly appeared again, and you will leave the new place. What is the strange thing? Everyone runs away and causes them to break.
What we need is a new generation of corporate leaders (both technologies are also non-technical), they will stand up and tell the truth - even if they are facing traditional and habits. The strategy of ease and retreat does not work. Non-technical leaders must take the XP team customers and should be involved in all times if necessary. Technical leaders must be willing to abandon the rights of control specifications and explore ways to make excellent software.
We need more brave people, but there is no distinctive experience. There is a vision on the ideal situation and have the courage to try to achieve the situation, and we need such a person. In the real XP mode, this vision will change when we move toward it, but we must advance.
Software development is painful and product is garbage, because you can allow it to be like this. This is our fault. The "Those" or "That Organization" can't play any effect, it will only extend this loop indefinitely. We need pain to think, require changes, and do a good look at yourself. It is very difficult to do it. Finally, a word is shielded: You are hope that the day will collect salary, or want to change the world?
