Summary IBM Rational Unified Process® (or "RUP®) is a complete software development process framework, which has several instances that are installed. From the RUP's process range, from the lightweight RUP that meets the short period of small projects, to satisfy large, it may be a more complete process that the distributed project team needs. All types and scale projects have successfully used RUP. This white paper illustrates how to apply RUP in a lightweight manner in a small project. We will explain how to apply Extreme Programming (XP) technology within a full project.
introduction
A small story a day, a manager found me asking me if I spent a few weeks for an investment that had just started to build a simple information system. I am tired of the head of the head, I am eager to start the new project to start the stimulus, so I have joy to this opportunity - I quickly started action, develop a new great solution, and get rid of the bureaucratic and procedures of the large institution I work. Chain.
Things are going smoothly in the beginning. In the first six months, I have worked for a long time and self-satisfied. My work efficiency is incredible, and some work is called masterpieces in my career. The development cycle is fast, and I can complete some new main parts in the system every few weeks. Simply and directly with the user's interaction process, we all belong to a team that is closely linked, and you can except for some procedures and documents. There is no formal design; the code is design, design is the code. Everything is perfect!
This perfection has only lasted for a while. As the system development is carried out, we need to carry out more work. Existing code must be improved with the changes of the problem, and we also refine the concept of the required work accordingly. I hired some developers to help develop. We work like a unit and often discuss with each other. This enhances communication with it to avoid form.
A year has passed.
We are still adding developers. The entire team from 3 people to 5 people, then 7 people. Every time you increase your person, you have to take a long time to learn. If you have no experience, it is difficult to understand and explain the complete system, even an overview. We began to use the whiteboard diagram to more formally display the overall structure of the system, the main concepts and interfaces.
We are still using tests as the main means of verifying whether the system meets the needs. Many new developers stand on the user's position, we found that the early informal needs of the project and personal contacts that they did not satisfy. We spend longer to plan the target content we have to build. As a result, we have retained the text records discussed without frequently recalling the decisions that have been done. We have also found that description needs and use scenarios help to introduce to new users of the system.
The size and complexity of the system are increasing, and unexpected situations - need to clearly describe the architecture of the system. At the beginning of the project, most of the architecture stored in my mind, and then scribbled in the note or moving map. However, as the project is getting more and more, the architecture has some out of control. Because everyone is as experience as me, they can't find some changes to the entire framework. We have to use more accurate terms to define constraints on the system architecture. Any changes that may affect the architecture need a team to discuss and eventually get my consent. After we wrapped around a circle, we discovered this problem. After receiving some major lessons, this is truly recognizing the importance of the architecture.
This is a real experience. It only tells some of the difficulties experience in this project. These experiences are only unusual in one aspect: some of our people have been together from the beginning, and time is more than one year. Developers often come in a project, there is no end, they have left, and they can't see their follow-up effects.
This item should be managed using some processes. There are too many things that will be missed, but it will bring new risks without using the process. Just as investment high-risk stocks, only the high return, almost unused project groups ignored key risks in the project environment, in fact, "expects the best results, but there is no worst case intend". SUMMARY This article discusses how to apply the process to the items described above. Our goal is to get the "appropriate level" of the process of use. Understand the challenges faced by the development team and the inactive environment they are, can derive the appropriate level of the process. If we understand these challenges, you can use just enough procedures to reduce risk. Whether it is lightweight or other, the "one knife cut" process does not exist. In the following, let's study this idea, that is, the right level of the process can be used as a function of a risk.
We focus on how to get the appropriate level of the process by using two popular methods: Rational Unified Process or referred to as RUP and Extreme Programming (XP). We demonstrate how to use RUP in small projects and how RUP handles XP uncommon areas. The combination of the two provides the project team with the guide required - reducing risk while completing the goals of delivery software products.
RUP is a process framework developed by IBM Rational. It is an iterative development method based on six industry-proven best practices (see RUP appendix). Over time, a RUP-based project will experience four phases: initial phase (Inception, refinement), construction, delivery phase. Each stage includes one or more iterations. In each iteration, you should put different workloads based on different requirements or workflows (such as demand, analysis, and design, etc.). The key driver of RUP is to reduce risks. RUP is refinered through thousands of IBM Rational customers and partners in thousands of projects. The following figure shows a workflow for a typical iterative process:
Typical iterative flow
As an example of how the risk affects the process, we should consider whether it needs to model business. If some major risks are not taken into account due to the understanding of the business, the system we build is wrong, then we should implement some business modeling work. Do we need to formally moderate? This depends on our public - if a small team will informally use the results, then we may only carry informal records. If other people in the organization will also use results or view results, then we may invest more efforts and ensure the correctness and understandability of the result.
You can customize RUP to meet the needs of almost any project. If you do not meet the installs or route maps that you need for your specific needs, you can easily create your own roadmap. The roadmap describes how the project plans to use the process, which represents the specific process instance of the project. This means that RUP can become simple or complex as needed, and we will explain in detail herein.
XP is a lightweight process-centric lightweight process in a small project (see XP appendix). It comes from Kent Beck, in about 1997 Chrysler C3 wage project, the software industry is concerned. Like RUP, XP is also based on iteration, and embodies a small scale, simple design, testing, and continuous iteration. XP introduces some effective technologies for the appropriate project and environment; however, there are also hidden hypotheses, activity and roles.
RUP and XP have different basic principles. RUP is a framework for process components, methods, and technology, which you can apply to any specific software project, and we want users to limit RUP usage. XP, from the other hand, is a process with more restrictions that require additional content to make it suitable for complete development projects. These different points explain a point of view of the software development industry: developing large-scale systems using RUP solving problems, and developing small systems are using XP as a solution. Our experience shows that most software projects are between the two - try to find the right level of the process suitable for their respective situations. One of the two is not sufficient. When you fuse the XP technology in RUP, you will get the correct amount of the process, which is both a need for all members of the project, and has solved all major project risk issues. For a small project team working in the high-trip environment, the user is part of the team, then XP is completely competent. For teams getting more and more scattered, the amount of code is getting bigger, or the architecture is not well defined, you need to do some other work. In the user interaction, there is only XP in a "contract" style. RUP is a framework that you can start from RUP, expand XP in a group of more robust technologies when necessary.
The following sections of this article describe a small project based on the RUP. In each stage, we have identified the activities and workpieces generated. Although RUP and XP have different roles and responsibilities, we will not handle these differences here. For any organization or project, the actual project member must associate the correct role during the process.
Project start - the starting phase is important for new development projects, and the starting phase is important. Before the project continues, you must handle important business and demand risks. For projects that enhance existing systems, the starting phase is relatively short, but its purpose is still the value and feasibility of determining the implementation of the project.
In the starting phase, you can create a business case in order to build software. The view is a critical workpiece in the starting process. It is an advanced description of the system. It explains the system for everyone, the user who can use the system, the reason for the use of the system, the functionality that must be available, and the existing constraints. The view may be short, perhaps only one or two. Views often include software that must provide key features for customers.
The following example shows a short view of a project, which is transformed to the Rational's external website.
In order to enable Rational's position to the world's leading level of electronic development (including tools, services, and best practices), customer relationships can be strengthened by dynamic, personalized websites, providing self-service, support and target content for visitors. New processes and technologies enabled to enable content providers to accelerate from a simplified, automatic solution to accelerate the quality of the publishing and increase content.
The four important activities in the RUP start phase are:
Develop the scope of the project. If we intend to build a system, we need to know its content and how it meets the needs of the people. In this activity, we capture enough detailed information on content and the most important demand, thereby dealing with product acceptable standards.
Plan and prepare business cases. We use views as guidance, define risk-mither strategies, develop start-up project plans, and determine known costs, schedules, and profitability balance.
Squit a standby structure. If there is no novelty in the planned system, and the framework is widely used, you can skip this step. Once we know the needs of our customers, we have to start allocating time to study the viable alternative architecture. New technologies can bring new and improved solutions for software issues. Early spending of the process, the purchase or creation system, and select technology, and it can also develop a starting original, which can reduce some of the main risks of the project.
Prepare the project environment. Any project requires a project environment. Whether you use XP technologies (such as knotting programming), or more traditional technologies, you need to determine the physical resources, software tools, and steps that the team will use. When making a small project development, it does not need too much "process time" to perform the starting process. You can often complete in a few days or less, the following description shows the expected workpiece other than the view.
An approved business case has the opportunity to identify the project from the perspective of the business. RUP and XP acknowledge that the best conclusions are derived in the early days, so as not to spend valuable resources in a project that will fail. As described in the "Planning Extreme Programming" book, XP is formed for the project and the answer involving which roles These two problems are relatively blurred (it seems to be the clearest in the existing project or system). However, in the research phase, the workpiece of XP processing is the same as the RUP initiation process.
Regardless of whether you have formally considered business in XP, you need to consider these issues in the RUP. Risk list You should keep recording a Risk List during the entire project development process. Use a risk list can be a simple list with a planned risk mitigation policy. Set priority for each risk. Any person-related personnel can see the risks of the risk and how to handle risks, but there is no general way to solve the risk.
Preliminary Project Plan This plan includes resource estimation, scale, and phase plan. For any project, these estimates are constantly changing, you must monitor them.
Project Acceptance Plan Your plan formally depends on the type of project. You must determine how customers think that your project has achieved success. For an XP project, customers will take the form of acceptance test. During more common processes, customers may not truly test, but the acceptable standards must be made directly by the customer, or by another role, such as system analysts that are directly in contact with customers. There may also be other acceptance criteria, such as creating end user documents and help, but XP does not involve this.
The start refinement iteration plans in RUP-based projects, at the end of the last iteration, you will give a detailed plan for the next iteration. At the end of iteration, you can assess the standards set up at the beginning of the iteration. XP provides some excellent skills for detective and measurement of iteration. Measuring standards are simple, you can easily merge them into iterative plans and evaluation criteria.
The starting case model although this sounds, it is more important, but it is quite simple. Use an example corresponding to the "story" written in XP. The difference between the time is that a use case is a complete action, initiated by a person or matter outside the participant or system, which is exactly the value of the use case. The use case may include several XP "stories". RUP is recommended to determine the user and role during the starting process in order to define the boundaries of the project. From the user's point of view, the complete set of operations helps to divide the system into a valuable part. This helps to determine the appropriate implementation characteristics, so we can deliver some achievements to customers at the end of each iteration (except for early starting and refinement iterations).
RUP and XP can help us ensure avoiding a situation, that is, 80% of the entire project, but it is not available. We have always hope that the system is valuable to users.
At this point, the use case model has little or only rarely providing support for identification examples and participants. It can be a simple text or UML (unified modeling language) diagram drawn by manual or use tools. This model helps us ensure that the correct features of concerns have been included, and it is useless to forget any features and allow us to easily view the entire system. Use the examples set priority according to a number of factors, including risks, important levels of customers, and technical difficulties. There is no need to official or excessive workpieces in the start phase. According to your needs, they keep them simply or official. XP includes guidelines for planning and system acceptance, but RUP needs to add more content in the early days of the project. These small amounts of adding may provide a lot of value for projects by handling a more complete risk. The goal of the refining stage refinement phase is to set up a baseline for the system architecture, which is a solid foundation for a large number of design and implementation work in the construction phase. Through consideration of the most important needs (those who have the greatest impact on the system architecture) and the evaluation risk evolution. The stability of the frame is to evaluate by one or more architectures.
In RUP, design activities focus on the concept of system architecture. For software-intensive systems, it is the concept of software architecture. Using the component architecture is one of the 6 best practices embodied in RUP, which is recommended to invest some time on the development and what is made. The time spent in this work can slow down the risk of fragile, rigidity system.
XP uses "metaphor" replaces the concept of the architecture. Metaphors only capture part of the frame, while the remaining frameworks are evolved with the natural results developed by the code. The formation of XP assumed framework is starting from generating a simple code and then continuous code reconstruction.
In RUP, the architecture is not just "metaphor". In the refinement phase, you build the executable architecture, which may reduce many of the risks associated with whether to meet non-functional needs, such as performance, reliability, and robustness. By reading XP literature, it is likely to infer some of the contents described in the refinement phase, especially the excessive concern of the infrastructure called too Xp, all in vain. XP believes that the work done in the creation of an infrastructure is not necessary, and the solution is too complex and the result is not worthless. In RUP, the architecture is not equivalent to the infrastructure.
The method of creating framework in RUP and XP is completely different. RUP recommends that you pay attention to architecture to avoid spread over time, increase project size, and the risk of adopting new technology. XP uses a simple or very well-understood existing architecture that can evolve as code. XP recommends that you do not design tomorrow, but to be implemented today. XP believes that if you keep your design as much as possible, you will be easy to manage. RUP wants you to consider the risk of this claim. If the system or part of the system has to rewritten in the future, then XP thinks that this measure is more sensible and more costly. For some systems, this is true, and when using RUP, the risk will also be concluded in your refinement phase. RUP does not believe that this is correct for all systems, and experience shows that there are probably disastrous.
Although there is too much energy for future possibilities (may never live) may be a waste but a sufficient concern for the future is not a savvy. How many companies can spend the cost of rendering or even reconstructing code?
For any project, you should complete these three events during the refinement phase:
Define, verify and set the baseline of the architecture. Use the risk list to develop alternate structures from the starting phase. We pay attention to whether the software in the concept is feasible. If the selected technology does not have novel or complexity for the system, this task will not cost too long. If you are adding content to the existing system, this task is not necessary if the existing architecture does not need to be changed. But when you really have the risk of architecture, you don't want your architecture to "touch your luck". As part of this activity, you may perform some component selection and make a decision to purchase / create / reuse components. If this requires a lot of work, you can divide them into separate activities.
Separate view. In the starting phase, you have developed a view. Because you have to determine the feasibility of the project, and there is a time inspection and evaluation system, there may be some changes to the view document and demand. Modifications to views and demand are generally performed during the refinement phase. At the end of the refinement phase, you have deeply understood the most critical use cases used to build and plan. The needs of the crowd need to be recognized, in the environment of the current architecture, as long as the entire system is developed according to the current plan, the current idea can be achieved. In the subsequent iterative process, the number of changes should be reduced, but you may have some time to spend some time in each iteration.
Create an iteration plan and set baseline for the construction phase. Now you can fill your details. At the end of each build iteration, you can reconsider the plan as needed and adjust it. The adjustment process is often necessary because the work that is needed is often incorrectly estimated, and the business environment will often change, and sometimes the demand will change. Set priority for use in cases, scenes, and technical work, then assign them to iterations. At the end of each iterative process, you plan to generate a working product that can provide value for people.
You can perform other activities during the refinement phase. We recommend you to establish a test environment and begin to develop tests. Although the detailed code has not been completed, you can still design a test, perhaps you can implement an integrated test. Programmers should be ready to perform unit testing and learn how to use project selected test tools. XP recommends that you design the test content before writing the code. This is an unique insight, especially when you add content to the existing code body. However, no matter how you choose how to test, you should establish a routine test system in the refinement phase.
The refinement phase of the RUP description includes research phases and input stages in XP. XP handling technology risk (such as novelty and complexity) is to use the "spike" solution, such as spending some time to estimate the workload. This technique is effective in many cases. When bigger risks are not reflected in a single use case or "story", you need some workers to ensure the success of the system and accurately estimate the workload.
In the refinement phase, you often update the workpiece, such as the needs of the starting phase and the risk list. The workpieces that may occur during the refinement phase include:
Software Architecture Document (SAD). SAD is a composite workpiece that provides a single source of technical information throughout the project. At the end of the refinement phase, this document may include a detailed introduction, describing the use cases that are important, and determine the key mechanisms and design elements. For projects to enhance existing systems, you can use the previous SAD, or if you don't think any risk, you will decide not to use the document. In all cases, you should be well thought out and recorded in the document.
The iterative plan for building a process. You can plan the number of iterations in the refinement phase. Each iteration has a specific use case, scene, and other assigned work items. This information is reflected in the iterative plan and sets the baseline. The review and approval plan can be part of the export standard in the refinement phase. For very small short-term projects, you can combine the iterations of the refinement phase with the starting process and build process. Key activities can still be done, but the resources needed for iterative plans and reviews will be reduced.
The goal built in the construction phase is to complete the system development. The construction phase looks in a manufacturing process in a sense, with key tasks to manage resources, control operations to optimize cost, schedule, and quality. In this sense, the management philosophy should be converted to the development of deployment products in the construction and delivery phase from the intellectual property development of the starting phase and the refinement phase. XP side weight construction phase. The construction phase is the stage of writing product code. The purpose of all phases in XP is to plan, but the focus of XP is to build code.
Every iteration in the construction phase has three key activities:
Manage resource and control processes. Everyone needs to understand their work content and time. You must ensure that workloads will not exceed your ability, and work can be done as planned.
Develop and test components. You build components to meet the needs of iterations, scenes, and other features. You will perform unit testing and integration testing.
Evaluate iterations. When it is completed iteration, you need to judge whether it is an iterative goal. If not, you must re-divide priority and manage the scope to secure the system on time.
Different types of systems require different technologies. RUP provides software engineers with different guidelines to help them create proper components. The demand proposed in the form of use case and supplementary (non-function) needs is enough to make engineers work. Several activities in RUP provide guidance for design, implementation, and testing different kinds of components. A experienced software engineer does not need to see these activities in detail. Experience is slightly lacking engineers can get a lot of help through best practices. Each team member can go deep into the research process as needed or just understand. However, they all refer to a separate process knowledge basis.
In XP, the "Story" drives the process. In an Extreme Programming Installed book, Jeffries et al. Believe that "story" is the programmiss for conversation. Sustainable and effective exchanges are beneficial. Although there is always a need to clarify some details, if the "story" is not detailed, it can not complete most of their work, then it can be said that "story" is not ready. The use case must be sufficiently detailed to facilitate the implementation of the programmer. In many cases, the programmer will help write the technical details of the use case. Jeffries et al. Believe that the session should be recorded in the document and attached to "Story". RUP also agrees with this point of view, in addition to using an example specifications, it can be used in informal form. The result of capturing and managing sessions is the task you must manage.
The length of XP is the construction phase. For most teams, there is a "crystallization of their" wisdom and guides ". The most significant practice in XP includes:
Test - programmers continue to write tests with the development of code. The test reflects "story". XP advocates you first writing tests, which is an excellent practice because it can force you to understand the "story" and make more problems in the necessary places. Whether before writing the code, you must write a test. Add them to your test package and ensure that tests are run each time code.
Reconstruction - Contacts the structure of the system without changing its behavior, making it easier or flexible. You need to judge whether there is a better practice for your team. Simple and complex discriminant varies from person to person. There is such an example, two very clever engineers in a project rewrite the other party every night because they think that the other's code is too complicated. This creates a side effect, that is, they always interfere with the work of other members of the next day. The test is helpful, but if they don't fall into the code dispute, then the team's situation will be better.
Ending program - XP thinks that the programming can create better code in a shorter time. There is evidence that this is correct. If you follow this practice, you need to consider the factors of many humanities and the environment. Is the programmer wants to try this? Your physical environment can meet this situation, that is, enough space to make two programmers work effectively in a separate workstation? How do you work remotely or work in other locations? Continuous integration - integration and construction work need to be continued, maybe more than once a day. This is a good way to ensure the complete code structure, which also allows sustained quality monitoring during integrated testing.
Collective code ownership - anyone can modify any code at any time. XP relies on such a fact that a set of good unit tests will reduce the risk of this practice. Let everyone know everything clearly cannot be limited to a certain scale - is a 10,000 line code, the 20,000 line of code is still less than 50,000?
Simple design - As the reconstruction process progresses, it is necessary to constantly modify the system design to make it simple. Returning again, you need to judge what exactly this work is just right. If you spend the need to design the architecture in the refinement phase, we believe that simple design will be completed quickly and soon becomes stable.
Code standard - this is always a good practice. There is no relationship between standards, as long as you use them and everyone can recognize.
RUP and XP think you must manage (and control) iterative processes. Measurements can provide better plan information because they can help you choose what is the most suitable for your team. Need to measure three things: time, scale and defects. This way you can get all types of statistics you are interested in. XP provides you with simple metrics to judge progress and predictive results. These measurements surround the completed "story" quantity, through the quantity of tests and the trend of statistics. XP has made an excellent episode for using the least amount of measurement criteria, because it is not necessarily an opportunity to successfully increase the success of the project. RUP provides you with an example of how to measure the content and how to measure it, and give an example of measuring standards. In all cases, the measurement must be simple, objective, easy to collect, easy to express, and not easily misunderstand.
What workpiece will be generated during iteration during the construction phase? It depends on the iteration is in the early days of the construction phase or later, you can create the following workpieces:
Component-Components represent part of the software code (source code, binary code, or executable program) or file containing information, such as a startup file or a README file. Components can also be aggregated by other components, such as applications consisting of several executable programs.
Training materials - If the system's user interface is more complicated, please write the user manual and other training materials as soon as possible on the basis of the use case.
Deployment Plan - Customers need a system. The deployment plan describes a set of installation, test and effectively delivers the task needed to the user. For Web-centric systems, we have found that the importance of deployment plans has increased.
Delivery phase iteration plan - When you are delivered, you need to complete and review the delivery phase iteration plan.
Is the code complete? I think the code is design and design is the code. The code is always consistent with itself, this is true. We believe that the cost is designed and the communication design is worthless, not just create a code. The following small stories will explain this.
The difference between RUP and XP except for the method of establishing a framework, further of other aspects. One of them is about the way of designing concepts. XP
An engineer has two such software project experiences, and the design is reflected in the code and can only find design information in the code. These two projects are about the compiler: one is to improve and maintain an optimization program for the ADA compiler, and another project is to transplant the front end of a compiler to a new platform and connect a third party code. Builder.
Compiler technology is more complicated, but it is also widely known. In these two projects, the engineer wants an overview of the design and implementation of the compiler (or optimizer). In each case, he receives a list of source code, probably a few feet thick, and is told to "see this information". He should be provided with a good picture with supportive text. The project of the optimization program is not completed. However, the compiler project has indeed successful, because a wide range of tests in the code development process, so the code quality is very high. The engineer spent a few days to study the code in the debugger to figure out its role. Personal loss is still in its second, and the cost of the team is not worth it. We did not complete the development after 40 hours of XP, and we spent a lot of personal efforts to complete the work. The main problem that only develops code is to write how good the code document is written, it does not tell you that it is to solve it, it only provides problems. Some demand documents will continue to explain the original goal of the project well after the initial user and developers continue working for a long time. In order to maintain the system, you often need to understand the design goals of the initial project team. Some advanced design documents are similar - the code often does not have a height abstraction, so any information cannot be provided to indicate what functionality can be implemented. In an object-oriented system, this is especially true because only the type files in the inside are difficult or even unable to perform threads. Design documentation guides you when you have problems in late period - there will be problems in the later stage.
This story shows that time creation and maintenance design document does help. This reduces the risk of misunderstanding and accelerates the development process. The way XP is to spend a few minutes to make a design or use the CRC card. But the team does not claim this, but only the code development. They have an implicit assumption, that is, the task is simple, we already know how to do it. Even if we successfully complete the task, then the next new person may not be so lucky. RUP recommends that you have spent some time to create and maintain these design workpieces.
The focus of the delivery phase of the delivery phase is to ensure that the software is available for end users. Delivery stages include testing for the release of the product, making a small adjustment on the basis of user feedback. At this moment of life cycle, user feedback is mainly focused on problems such as accurately adjusting products, configuration, installation, and availability.
Earlier release, often publishing is a good way. However, what is our purpose to achieve? XP did not clearly explain this problem, and did not process the issuance of publishing business software. In the internal project, you can find shortcuts for resolving these issues, but even if you need to edit documents, employee training, etc. So what is technical support and change management? I hope that customers can control these contents, is this possible? Bruce Conrad indicates that the software does not want to obtain in his XP Infoworld Comments. You must weigh the interests and changes in the interests of the software and the possible instability.
When you decide to release, you must provide things that have much more than the code than the code. The activities and workpieces in the delivery phase will guide you to complete the software development process of this section. These activities are mainly to provide you with available products to your customers. The key activities in the delivery phase are as follows:
Determine the end user support information. This activity is relatively simple, you only need to provide a list. But be sure to make sure your organization is ready to conduct technical support for customers.
Test the deliverable product in the user's environment. If you can simulate the user environment within the company, it is best. Otherwise, go to the customer's company to go, install the software and ensure it can run. You must answer your customers in our system: "But it works fine in our system."
Precisely adjust the product based on user feedback. If possible, schedule or multiple Beta test cycles when you deliver your software to a limited number of clients. If you do this, you need to manage the Beta test cycle, and consider customer feedback in your "finishing". Deliver the final product to end users. For different types of software products and release, you need to process many issues related to packaging, manufacturing, and other product issues. You will not only copy the software into a folder, and then send a message to the customer telling that the software is already in place.
As with other stages, the format and complexity of the process are different. However, if you don't pay attention to deployment details, it may cause a few weeks or monthly well-developed work before entering the target market to fail.
You can generate a number of workpieces in the delivery phase. If your project involves future release (how many items do not involve?), Then you should start determining functionality and defects for the next release. For any project, the following works are critical:
Deployment Plan - Complete the deployment plan you begin with the build phase and use it as a delivery.
Version Note - It is a relatively few software products that do not include instructions that are critical to end users. It can be planned to have an annotated, consistent format for comments.
Delivery Phase Data and Document - This type of information can take many forms. Can you provide all content online? Will you guide? Is your product help intact and available? Don't think what you know, customers are also understanding. Your success is to help your customers succeed.
Conclusion Building software is far more than the writing code. A software development process must focus on all required activities to publish high quality software to users. A complete process does not have to be huge. Through centralized discussing the primary activities and workpieces in the project, we have shown a small but complete process. If you are performing an activity or creating a workpiece is helpful for the risks in the mitigation project, then please do it. You can use more or less processes and formats as needed.
RUP and XP do not have to be excluded. By combining these two methods, you can get a process to help you deliver higher quality software than now. Robert Martin describes a process called DX that he uses it as an accessory of RUP. It is an example of a process constructed from the RUP framework.
An excellent software process can use the best practices through industry verification. Best practices have been used in real software development organizations and have experienced time test. XP is currently widely concerned. It is centered on code and provides a commitment: the minimum process cost is the largest productivity. Many of the techniques in XP are worth considering and adopting in the appropriate situation.
XP Follow "Story", Test and Code - it discusses the plan with a certain depth, but does not explain how to obtain a plan. XP means you can do some other work, such as "using some cards for CRC design or draft some kind of UML ..." or "Please do not generate documents or other workpieces", but only one. RUP I hope that when you customize and update the development plan, just consider creating useful and necessary things, and pointing out what these things should be.
RUP is a process that can handle the entire software development cycle. It pays attention to best practices and has passed thousands of items. We encourage techniques for research and invention to produce best practices. With the new best practice, we want to incorporate them into RUP.
Appendix: Rational Unified Processrational Unified Process, or RUP, providing a regular way of software development. It is a process product developed and maintained by IBM Rational. It provides several types of ways to use the same type. RUP also provides information to help you use other Rational tools during software development, but it does not require Rational Tools to be effectively applied to the entire organization, and you can integrate the Rational tool with other vendors. RUP provides guidance for all aspects of the software project. You don't need to perform any specific activity or create any specific workpiece. It only provides information and guidelines, you can decide which applications to your organization. If there is no specific route map to fit your project or organization, RUP also provides some guides to help you tailor your procedure.
RUP emphasizes some of the best practices developed by modern software as a way to reduce the inner risks brought by developing new software. These best practices include:
1. Iterative development 2. Management requirements 3. Use the component-based architecture 4. Video model 5. Continuous quality verification 6. Control change
These best experiences are integrated into the definition of Rational Unified Process:
Role - The series of activities executed and the workpiece owned. Discipline - Key areas of software engineering, such as demand, analysis and design, implementation and testing. Activity - Definition of workpiece generation and evaluation method. Workpiece - Work products generated or modified in the execution activity.
RUP is an iterative process that determines four phases of any software development project. Over time, each project has to experience the starting phase, the refinement phase, the construction phase, and the delivery phase. Each stage includes one or more iterations, where you can generate executables, but the system may be incomplete (except possible starting phase). In each iterative process, you implement the activities in several disciplines at different details. Hereinafter is an overview of RUP.
RUP overview
The Rational Unified Process, An Introduction, Second Edition is a good overview of RUP. You can find further information on Rational's Web site www.rational.com and evaluate RUP.
Appendix: Extreme Programming Extreme Programming (XP) is a software development discipline developed by Kent Beck in 1996. It is based on four values: communication, simple, feedback, and courage. It emphasizes the continuous communication of customers and development team members to set up a site customer in the development process. The on-site customer decided to create the content and order. It is simple to reflect the collections of the code and create the smallest non-code workpiece. Many short-term issues and continuous unit tests established a feedback mechanism. The courage means that the correct thing is completed, even if it is not the most popular. It also means honest with what you can do and can't do.
12 XP practices support these four values. They are:
Developed development: The function of the next version is determined by combining the use of priority "stories" and technical estimation.
Small versions: The software is often released to the customer with a small incremental version.
Metaphor: Metaphor is a simple, shared "story" or description explains how the system works.
Simple design: It is easy to ensure the design is simple. Constantly find complex points in the code and remove them immediately.
Test: Users write test content to test the "story". Programmers write test content to discover any problems in the code. Write the test content before writing the code.
Refactoring: This is a simplified technology that is used to remove duplicate content and complex content.
Ending programming: Two members in the team use the same computer to develop all the code. One person writes code or drivers, and another person reviews the correctness and understandability of the code. Collective code ownership: Anyone has all the code. This means that everyone can change any code at any time.
Continuous integration: Create and integrate systems multiple times a day, as long as any task is completed, it is going to do.
40 hours a week: the programmer cannot guarantee the highest efficiency when fatigue. Optics for two weeks is absolutely not allowed.
On-site customers: A true customer is working in the development environment in the universal system, helping to define the system, write test content and answer questions.
Code standard: Programmer adopts a consistent coding standard.
There are currently three books for XP:
1. Extreme Programming Explained 2. Extreme Programming Installed 3. Planning Extreme Programming
There are also further information on XP on some web sites.
Reference
You can see this article in our website on our world.
About the author gary pollice
