General Software Project Development Process Specification (3)-implementation stage

 

Execution phase

 

Figure 5-1 tasks and artifacts in the execution phase

 

• Requirement Analysis

Analyze the key requirements of the product, the requirements that have an impact on the architecture design, and the high risk requirements, until the degree of analysis can fully carry out the interface prototype design and architecture design work.

The requirement specification includes:

 

Business or business needs	Requirements on products or systems from a commercial or business perspective. It is summarized at a macro level to meet the functional, performance, quality and other requirements that customers must achieve or win market competition. What to do Scope Requirements on results
User Requirements	Describe and summarize the things or tasks that the user can do using the software product or system from the perspective of the customer's use of the software product or system.
Functional requirements	According to the aboveUser RequirementsA list of usage plans. It lists the features that developers must implement for software products or systems.
Performance Requirements	Running Speed, capacity, concurrency Performance Resource Utilization Feedback speed and accuracy of external input Error Load Capacity
System Requirements	Required Runtime Environment (Including operating platform, network and other hardware requirements) Requirements for compatibility with other systems (Including compatibility requirements with operating systems, databases, browsers and other application software) Interface requirements with other external systems and components
Quality requirements	Important quality marks for users (Reliability, efficiency, flexibility, security, interoperability, stability, soundness, and availability) Important quality marks for developers (Maintainability, multi-purpose conversion, reuse, and testability)
Other requirements	Requirements that do not fall within the scope of the above requirements but are affected by other environments and commercial contracts. Any special standards of the country or region Special requirements for the software user interface Requirements related to intellectual property rights Market and industry specifications for Software Special requirements of customers
Limitations of Development	The factors that have a significant impact on the success of development are the limitations of development capabilities: Personnel limitations Technical constraints and limitations Special requirements of customers

 

Table 5-1 Requirement Analysis

 

The Requirement Analysis Report can be prepared in a variety of ways, such as organizing all "non-functional requirements" into "external interface requirements", "quality attribute requirements", and "requirement constraints ". [Example: Figure 5-2]

 

Figure 5-2 Requirement Specification

 

• Interface prototype design

After clarifying the key requirements of the system, you can design the interface prototype, obtain user feedback, and determine the UI tone of the product as soon as possible. At the same time, you must compile a document "interface design overview" to serve as a guide for subsequent interface design work.

The interface design overview includes:

• Design Concept
• Source or reference of Idea
• Key Points of Design
• Comparison with similar product Interfaces

 

• Architecture Design

The architecture design starts from the key requirements, establishes a conceptual architecture, and gradually refines and verifies the architecture. Final generation of architecture design specifications and architecture baselinesCode.

Architecture Design Method: you can design the architecture from several different perspectives, and then summarize the complete design. (Five views of the architecture design, for example, Figure 5-3 ])

Figure 5-3 5 view of Architecture Design

 

The Architecture Design Manual includes:

 

OverviewDescription	Describes the purpose, applicability, and design principles of the compilation.
Logical architecture	Follow the function. Its design focuses on functional requirements. Refined function unit General mechanism of discovery Refine the domain model Determine subsystem interfaces and interaction mechanisms
Development Architecture	FollowProgramPackage. Its design focuses on the quality attributes during the development period, such as scalability, reusability, portability, comprehensibility and testability. Determine the dependency between the packages to be developed or directly used Determine the technology and framework used
Data Architecture	Focus on the storage solution of persistent data. Its design focuses on "data requirements ". Persistent Data Storage Solution Data transmission, data replication, data synchronization, and other policies
Operating Architecture	Focus on processes, threads, objects, and other runtime concepts, as well as related concurrency, synchronization, and communication issues. Its design focuses on runtime quality attributes, such as performance, scalability, continuous availability and security. Determine which processes and threads are introduced Determine active objects, passive objects, and control relationships Process process thread creation, destruction, communication mechanism, resource contention, etc. Protocol Design
Physical Architecture	Focus on how software systems are finally installed or deployed on physical machines. Its design focuses on "installation and deployment requirements ". Determine the physical configuration Scheme Determine how to map the target program to a physical node
TotalEnd	Summarize the above design and describe the architecture baseline.

 

Table 5-2 Architecture Design Specifications

 

Another important task of architecture design is to write the architecture baseline code, describe the baseline code, and verify the architecture. It is also the basic code for subsequent development. The architecture baseline code includes:

• All Engineering Projects
• Project directory structure
• Package Structure
• Import all dependency packages
• Basic public code
• Architecture framework code
• Architecture framework sample code and test code
• Database framework

Figure 5-4 and figure 5-5 demonstrate the work of the software architect and the content of successful software architecture design:

 

Figure 5-4 Work of the Software Architect

Figure 5-5 successful Software Architecture Design

 

 

1. Software build

 

The software can be built in stages, and each stage can be developed in incremental mode. Several build methods are used to build the software and finally release the phased product results.

(Note: HereThe meaning of the term "stage" is different from that in other parts of this article)

 

• Phase plan

The construction phase plan includes:

• Determine the functions to be implemented in this phase
• List stage tasks
• Planned build quantity
• Refine the work of this phase in the development schedule

 

• BuildBuild

For details, see the following section.

 

• Phase product release

After the build phase is complete, the product results in the release phase will be presented to users and received feedback from users. At the same time, we will make a summary of the phase.

The release list includes:

• Product Version and date
• Corrected bug
• Modified Functions
• Implemented new functions
• Other Instructions

The stage summary report includes:

• Completion of phase tasks
• Progress plan execution
• User feedback
• Main problems encountered in this phase
• Suggestions for improvement in the next stage

 

 

2 Build

 

Build build executes the development tasks in incremental mode. Each build cycle generally does not exceed two weeks. Each build is released as an internal version and submitted for testing. The problems found during the test are left to be solved by future build.

 

• BuildPlan

The build plan includes:

• Version Number of this build
• Duration of this build
• Task of this build
  • Bugs left to be resolved
  • This should have been implemented by the previous build, but it is postponed to the function implemented by this build.
  • New features to be implemented
  • Other tasks
• Job assignment

 

• Demand refinement

According to the build plan, the requirements to be implemented by this build are refined until detailed design can be performed. Compile the test plan for this build after you have refined the requirements.

The test plan includes:

• Function Testing
  • Features to be tested
  • Test Time
  • Test Method
  • Acceptance Criteria

• Other tests (performance testing, border testing, user interface testing, availability testing, security testing, etc)
  • Content to be tested
  • Test Time
  • Test Method
  • Acceptance Criteria
• ......

 

• Interface Design

Design the user interface according to detailed requirements. After the interface is determined, you can write test cases.

The content of test cases includes:

• Function modules corresponding to test cases
• The nature of test cases (functional test cases, performance test cases ,......)
• Input (or operation steps)
• Expected output
• Actual output (enter it after testing)
• Pass (enter it after testing)

 

• Detailed Design

Detailed implementation of each requirement, for important design decisions,AlgorithmPublic modules and external interfaces must be recorded in the form of module design documents. The module design document includes:

• Module name
• Design Philosophy
• Design charts (class charts, flowcharts, etc)
• Key points (package, interface, class, method, algorithm, design mode)
• Test Method

 

• Coding and unit testing

Coding and unit testing are the work of developers. unit testing is required for all important code. coding must follow the following guidelines:

• Comply with coding specifications
• Before coding, you must fully understand the relevant requirements.
• Design before coding to streamline the process
• Pay attention to the flexible use of design methods and models
• Overall considerations to make code compliant with the architecture and easy to test
• Exception conditions and critical conditions should be fully taken into account during design
• Copy-paste prohibited, Pay attention to extracting public code and refactoring during the Encoding Process
• Logs must be recorded for exception handling.
• Flexible Use of assert ()/verify ()And other assertions to help debug the program
• Unit testing is the work of programmers. Therefore, code must be strictly tested after coding.
• After the function code is complete, you must first do the following 4Things:
  • Compile the Code to ensure that the compilation passes
  • (Do not run the program) perform a comprehensive check on the code
  • Start the program in debug mode, execute the code one by one line, and pay attention to the debugging output.
  • Change the condition so that the code can go through all program branches as much as possible
• Check inMake sure that the code can be compiled

 

•  Create build

You need to freeze the code before the Code integration is released. Everyone checks the code to be submitted and ensures that the compiled program can be started on the test server and the interface can be opened normally. You also need to submit the build list.

The "build list" includes:

• Build version number and date
• Corrected bug
• Modified Functions
• Implemented new functions
• Other Instructions

 

• Integration Test

Perform test cases in accordance with the build list in the test plan, and compile the test report after the test is completed.

The test report includes:

• Test Case Summary (number of use cases, number of passed use cases, number of failed use cases, etc)
• Bug Summary (total number of bugs, number of new bugs, number of closed bugs, and bug trend charts)
• Test plan execution
• Test Summary

 

Coming soon:General Software Project Development Process Specification (IV)-control and end stage

 

Codeproject