FAQ: Implementation Complete Phase

Transcription

1 FAQ: Implementation Complete Phase Question 1: How can I determine if the Implementation Complete milestone has been met? Response: There are several industry accepted measures for the Implementation Complete milestone. The primary indicator is whether the code set can be checked into the source code control system along with a completely functional build of the application. The project manager should be carefully monitoring code velocity during development. As the Implementation Complete milestone date approaches, the development team may react to time line pressure and attempt to check in more code to cover the requirements. Code velocity is a measure of how much code is completed in a given time period. Marked increases in code velocity indicate poor quality. Conversely, if code velocity remains relatively constant and the requirements have been met, then the likelihood of reaching the Implementation Complete milestone is increased. Implementation Complete cannot be formally measured without at least one cycle of integration testing. At this point in the project, test plans should be in place and conducting the integration test plan should be possible. Defects may be discovered during this initial test but all functionality should be in place, and the defects should be at an expected level. There will be defects in the application at this point, but there should not be missing functionality or major defects indicating that the code still requires some major modifications. All performance objectives should be met at this point. The development team should not be making requests to add any code and should only respond to identified defects. There is no global measure of acceptability, and these metrics will vary from company to company and project to project. Experience in projects will help determine acceptable levels. Question 2: What steps can be taken to ensure the Implementation Complete milestone will be met? Response: As with any phase in a software development project, success is largely based on proper planning and adherence to the plan. A diligent project manager will not only carefully plan the project but will also measure the progress against defined deliverables. The implementation phase should not be loosely defined as a general phase of writing code with the only deliverable being the completion of all code. Instead, deliverables during the implementation phase should be defined and matched against the requirements. Each of the shorter term deliverables should include code and build check-ins. Quality assurance and integration testing does not have to wait until a formal Implementation Complete milestone has been reached. In fact, this form of testing can be done with each major build submission and is useful to measure the progress of the implementation phase. If proper testing is performed during implementation, the completion of this phase can be reduced to a mere formality without surprises. Good

2 and consistent communication regarding the status of the overall project helps identify problems earlier in the process and allows sufficient time to respond to those problems in effective ways. As with other phases, the implementation phase should be viewed as an iterative process that may include some changes to the requirements and ultimate validation and verification through appropriate testing. The iterations will progressively move the development toward the next formal milestone. Question 3: Who should determine if the Implementation Complete milestone has been met? Response: Many organizations leave the declaration of Implementation Complete to the developers. The viewpoint is often that the developers are the only ones who understand the code well enough to determine the status. In fact, the developers are knowledgeable about the code, but they are not the ones who should determine whether the Implementation Complete milestone has been reached. The developers should use their judgment to inform the project manager of when they think they have reached this important milestone, but this is just the beginning of the formal process to determine if all requirements have been met appropriately. The project manager should review the status of the application as a first step in formal milestone approval. This review should include a check to ensure the developers have declared their completion of the coding, that a full code set has been checked in, and a fully operational application has been built from the source code. Once these conditions have been verified, a formal system test should be scheduled with quality assurance (QA), and the results should be used as further verification of the completion of the phase. If QA approves the build for acceptance into formal system testing, then a formal sign off meeting can be scheduled. This meeting should include the project manager, the lead developer or development manager, the QA manager, and any other major application stakeholders within the company. There should be no major issues raised at the formal sign off if appropriate steps have been taken previously to ensure approved processes have been followed. Question 4: Is Implementation Complete a useful milestone in agile development? Response: Agile development is based on iterative cycles and efficient application development. Agile development does not use a completely new and different basic life cycle, but rather, it breaks the project into mini-projects that individually use traditional life cycles. Even a traditional methodology is iterative to a degree, so the Implementation Complete phase is an important part of both methodologies. During a project under Agile development, each mini-project will have functional requirements to address. Completion of the code to address these requirements must still be measured by testing the completed portion of the application. The developers must still declare their code complete for that part of the application and must check this code and an associated build into the version control system. Because the miniprojects are smaller and easier to manage individually, the phase signoff is not as

3 complicated or formal, but the process remains similar to the traditional approach. Failure to include Implementation Complete milestones in agile development only allows the developers to work with an open-ended completion with no formal verification that the requirements have been met. If this happens, then later in the process, the application subsystems will be integrated with unpredictable results. In an informal way, agile development creates a much closer coordination between development and quality assurance and brings the validation and verification process to the code module or subsystem level. These more frequent checks of the code from a system level reduce the possibility of major shortfalls occurring. Question 5: What steps must the development team perform at the Implementation Complete milestone marker? Response: The development team is responsible for much more than just declaring they are finished with the coding effort; a hands-off, transfer of responsibility is a formula for trouble, so the steps the development team should take are more inclusive. First, the development team members must internally determine if they have met all of the requirements of the application. Properly trained developers, with the help of the project manager, should have a full understanding of the level of completion they have met. In a properly managed project, the code would already have undergone a variety of testing, and the most critical issues should have been addressed. At this point, the developers should feel confident that the quality assurance group will not find any defects that require major coding efforts to resolve. With this level of confidence in hand, the developers should check in the complete source code along with a build of the application from the source code. A formal document should be submitted to the project manager declaring Implementation Complete from the development manager. This document should identify the process followed to come to that conclusion. The development manager should conduct a presentation to the project manager and the quality assurance manager. Other members of the development, testing, support, and technical writing teams are often included in this presentation to help prepare them for the tasks they will be performing during the completion of the project. The presentation should provide evidence that the application operates as intended and meets the requirements. This meeting serves as support for the remainder of the formal phase complete process. Question 6: What process should be followed if the Implementation Complete milestone review fails? Response: In a perfect world, the project manager has conducted an efficient and thorough project throughout the development phase and the Implementation Complete milestone review becomes a mere formality. Software development projects do not operate in a perfect world. Not all project managers are able to respond to every situation with effective solutions. Some projects do fail the Implementation Complete

4 milestone review. When this failure occurs, appropriate steps must be taken. The first and most obvious step is to examine the reasons the review failed. The two primary reasons are that some of the project requirements were not met or that the quality of the code submitted was below acceptable levels. These measures are not always entirely clear but are more the overall opinion of those stakeholders approving the phase sign off. Worse yet, requirements are identified at this stages that should have been included in the original functional requirements document but were overlooked. Many times, the formal review of Implementation Complete serves to point out where the project was not appropriately planned and documented in earlier phases. Regardless of the reason for phase approval failure, the same process should be followed. The project should return to the phase that is appropriate for correction of the problem. If the requirements were not written completely or accurately, then the project should return to the requirements planning phase. If the design was not done well and problems have been identified later, then the application, or parts of it, should be reworked. Similarly with the code, if there are significant major defects or some functionality is missing, then the development efforts must come into play. Iteration is a part of most projects, and returning to an earlier phase is not necessarily a long or difficult process. If the changes are minor, then earlier phase sign-offs only require notation regarding the iterations. Major changes require revisiting the formal sign-offs, although this might point out a problem with the process or the previous reviews because the project should not have been originally allowed to continue if these problems were present. Question 7: Does the enforcement of the Implementation Complete milestone create a false shift of responsibility to quality assurance? Response: Software development projects can become tricky problems. Each group involved is often anxious to finish its part of the project and transfer the responsibility to another group. Software development is notorious for time and cost overruns, so completion of a phase on time and within budget is a major step for the responsible group. These pressures cause the development group to expend all efforts to bring the implementation phase to completion and transfer responsibility of the project to the quality assurance group. The error in logic with this scenario is that all members of the project group are ultimately responsible for the entire application. One player on a sports team cannot disavow responsibility for the eventual success of the team. The offensive players on a football team cannot say they are no longer responsible for winning after they leave the field and the defense takes over. In the same way, the planners, designers, coders, testers, writers, and others involved in a project should consider their responsibility for the application to be consistent throughout the project.

5 If a proper environment of teamwork and shared responsibility has been established in the development group, there will not be a shift of responsibility at any time during the development process. Instead, there will be a shift of the most active team members and the tasks that are performed. While one part of the team takes the development field, the remaining team members provide information and support as necessary. When the coders successfully pass the Implementation Complete milestone, they will become the primary support group for the quality assurance organization, but they will remain responsible for the quality of the code. Quality assurance is responsible for measuring application quality, and to do this job, they need the rest of the development organization for support of progress. Question 8: What is the most effective way to transition from coding to testing? Response: There is a difference between a process and the methods used to perform the process. The transition from coding to testing is a relatively simple process that passes through the Implementation Complete doorway. The process is for development to determine it has finished the application, the code and a build is checked in, the phase review is conducted, and the process continues with system testing. The methods used to accomplish these tasks can vary substantially. The declaration of code complete is most efficient if it can be based on a well-written requirements document and functionality-to-code mapping. These documents provide a checklist for the development group to log completion. A good source code control system with appropriate versioning capability is the most efficient way to identify the specific code and build associated with the code completion. This system should also allow the code to be locked to the build so no changes can be made to the official build used for testing. Builds, along with the appropriate installation and setup programs, documentation, configuration files, test data, and any other materials needed to test the complete application can also be included with these version control systems. The Implementation Complete phase review should be an organized and planned process to avoid incomplete evaluations and iterations. The project manager should conduct an informal review to ensure the formal review will be conducted smoothly. The more organized all of the documentation is and processes required to transition from one phase to another, the more efficient the transition will be. Question 9: How should the formal milestone review be conducted for the Implementation Complete phase? Response: The formal review process for Implementation Complete is just one part of the process to transition from the development phase to the testing phase. The formal review is typically a meeting conducted in which the objective is a sign off of the phase completion document. The meeting should be conducted by the project manager. Attendees should include the development manager, the quality assurance manager, and any other major project stakeholders. The meeting should be planned in advance and all participants should have already received a preview of the application

6 from the project manager. During the actual meeting, the project manager should conduct a brief presentation of the project highlights and evidence that the milestone has been reached. This evidence could include requirements matching, results of initial system testing, and a short demonstration of the application. A question and answer period should follow the presentation, and if all goes according to plan, the next step is the formal phase completion document sign off. If any issues are raised that cannot be addressed and the milestone review fails, then a clear plan for the next steps should be identified before the meeting is adjourned. In addition, failure at this juncture should also prompt scheduling of a review meeting with the same participants to determine the cause of failure and areas for improvement in future projects. Question 10: Is it possible to concurrently implement and test an application and eliminate the necessity for an Implementation Complete milestone? Response: There are two questions to address. The first question is whether implementation and testing can occur simultaneously and the answer is a definite yes. Not only can these activities occur at the same time, they should occur at the same time. Implementation requires constant testing to ensure the coding is performed correctly. Unit testing should be conducted by the coders as code is developed, and integration along with some system level testing should be done as modules are completed. The concurrent testing process reduces the defect levels substantially during the implementation phase and ushers the completion of this phase of development toward approval. The second question concerns the necessity for an Implementation Complete milestone. The milestone serves to verify all of the necessary steps in the implementation phase have been completed before the project formally moves into the testing phase. Even though significant testing may have already occurred, the completed application cannot be tested until, by definition, the coding is complete. If there is no Implementation Complete milestone to identify this marker in the project, then the final code and build cannot be identified. The advance testing can shorten the testing phase significantly, and some may argue that with sufficient testing, the lines between the implementation and testing phases are blurred so it can all be considered one big phase; however, lack of a formal distinction between the phases will ultimately result in allowing coding to continue while system testing is in process. The inability to define defects versus incomplete requirements implementation will cause unnecessary iterations and a prolonged project time line.