Software Construction (from Code Complete, Steve McConnell):

• Problem definition
• Requirements development
• Construction planning
• Software architecture, high level design
• Detailed design
• Coding and debugging
• Testing: unit testing

  And for larger scale projects:

• Integration testing
• Integration
• System testing
• Corrective maintenance

1. Problem definition - Clear statement of the problem this iteration is supposed to solve, and perhaps how this fits into the larger scale, or longer term, problem you are trying to solve or investigate with your project or system.

2. Requirements - checklist from Code Complete:
   Specific functional requirements
   1. Are the inputs to the system (or program, piece of code, function, module) specified, such as the input source, accuracy, range of values, and frequency?
   2. Are the outputs from the system specified, their destination, such as the output desired accuracy, its range of values, frequency of output, and format?
   3. If you are using a GUI interfaces or web page, is the specific output format specified?
   4. If you are using distributed computing and connecting to multiple computers, are all external hardware and software interfaces specified? Are external communication interfaces specified, hand-shaking, error-checking, and communication protocols?
   5. If you have other users involved in these requirements, are all the tasks the user wants to perform specified? Is the data used in each task and the data resulting from each tasks specified?

      Quality requirements:

   6. If timing or speed is important, are the timings of operations specified, such as processing time, data-transfer rate,and system throughput? If necessary is the expected response time from the user specified for all necessary user input?
   7. If security is an issue, is the level of security specified?
   8. Is the reliability specified, including the consequences of software failure? vital information that needs to be protected from failure, and strategy for error detection and recovery?
   9. If machine memory or disk space is an issue, is the minimum machine memory and free disk space specified?
   10. Thinking ahead about future development - is the maintainability of the system specified, its ability to adapt to changes in specific functionality, and if necessary changes in operating environment and changes in its interfaces with other software? Is scalability an issue - can your program work just as well with 100/1000/1000000 users?
   11. Testing your program: is the definition of success included? of failure? Is each requirement testable?

3. Architecture of your program - software architecture is the high-level part of software design, the frame that holds the more detailed parts of the design (see Code Complete: p. 43)
   
   Specific architectural topics to consider:
   1. Is the overall organization of the program clear? Are major building blocks well defined, including their areas of responsibilities and interfaces with other building blocks?
   2. Are the most critical classes described and justified?
   3. Is the design of your data described? If you use a database, is its organization and content specified?
   4. What sort of user interface is being used for this iteration? Is this strategy described? Is the user interface modularized so that changes won't affect the rest of the program?
   5. Is a strategy for handling I/O described and justified?
   6. If applicable, are resource use estimates and a strategy for resource management described and justified for scarce resources like threads, database connections, network bandwidth?
   7. If security is an issue, are security requirements described?
   8. Does your architecture describe how scalability will be achieved?
   9. Is a coherent error-handling strategy provided? If needed, is an approach to fault tolerance defined?
   10. Is the architecture designed to accomodate likely changes?

4. Summary of your preparation for software construction (from Code Complete, p. 59):
   1. The overarching goal of preparing for construction is risk reduction. Be sure your preparation activities are reducing risks, not increasing them.
   2. If you want to develop high quality software, attention to quality must be part of the software development process from the beginning to the end. Attention to quality at the beginning has a greater influence on product quality than attention at the end.
   3. The kind of project you're working on significantly affects construction prerequisites - many projects should be highly iterative, others should be more sequential.
   4. If a good problem definition hasn't been specified, you might be solving the wrong problem during construction.
   5. If good requirements work hasn't been done, you might have missed important details ofthe problem. Requirements changes cost 20 to 100 times as much in the stages following construction as they do earlier, so be sure the requirements are right before you start programming.
   6. If a good architectural design hasn't been done, you might be solving the right problem the wrong way during construction. The cost of architectural changes increases as more code is written for the wrong architecture, so be sure the architecture is right.