Technical solution domain [technicl solution]

Technical solution domain [technical solution]

Technical implementation includes the following:
Design products and product components
Manage interfaces between product components
Compile and schedule product components
Product integration and release
Ensure that the demand is sufficient
Product delivery and use [test team, external customers]

Design
Advanced Design Stage
Architecture Design
Detailed Design
Interface Design
Database Design
Module Design
Data structures and algorithms

Architecture Design Principles:
Suitability
Structural Stability
Scalability
Reusability

--------------------------
Suitability:
Applicable to functional and non-functional requirements
The market decides the fate of the product, not the technology
There is no best, only the most suitable
Develop Multiple candidate solutions and select the most appropriate one

Stability:
Stable requirements determine the architecture
Variable requirements determine system scalability

Scalability:
Changes are the eternal theme. adapting to changes determines the future of products.
The relationship between stability and expansion: A dialectical relationship
The product has no future if it is stable and cannot be expanded.
Stability is the foundation of scalability, and structural stability can be used for sustainable expansion.
Reserved APIs

Reusability:
Reusability is designed.
PUBLIC PART
Abstraction
Reuse improves productivity


User Interface Design Principles:
Ease of use
Easy to operate
Easy to use
Consistent Style
Timely feedback
Error Handling
Beautiful
Reasonable layout
Appropriate color combination

Database Design Principles:
Select an appropriate database
Database Optimization
Optimize table structure
Standardization (third paradigm)
Optimize data environment parameters
Enhance hardware performance, internal, CPU, etc.

Module Design Principles:
Transparent
Open interfaces and hide internal implementations
High Cohesion
The correlation between elements in a module is high.
Low Coupling
Low dependencies between modules
[
The performance of the module determines the system performance.
The performance of a single module determines the performance of a function of the system.
The Collaboration Performance between modules determines the overall performance of the system.
]

Encoding
Code Specification
Unit Test
Code Review
----------------------

Code Specification
Basic coding specifications
Typographical
Note
Name
Advanced coding specifications
Summary of experiences in specific languages [C \ c ++ \ Java]

Unit Test
Functions and values:
Increase our confidence in the program
Testing can convince us that the program has done what we expect.
Discover bugs as soon as possible
The longer a bug is hidden, the higher the cost of fixing it.
Fundamentals of regression testing

Unit Test requirements:
Learning Test Tools
Learning Test Methods
Write Test Cases

The possibility of a bug cannot be detected:
High code quality [less likely]
Incorrect testing methods and policies, low test case quality, and low coverage rate

Write Unit Tests
Exploitation tools
Test Method
Equivalence Class, boundary value, and logical Overwrite
Test Policy
Determine whether the test case is worth writing based on the logic complexity [loop, judgment level]
Use assertions instead of printing
Test Coverage: code coverage, branch coverage, and path coverage

Possible consequences of not writing a unit test:
Project continuous broadcast Delay
No-break overtime
Lose confidence in the project
A large number of developers leave
Products cannot be pushed to the market

Audit
Key Points of QA Audit
Test Case?
Whether the test case meets the coverage required by the organization
Indicates whether the test bug is recorded.
Whether the cause and type distribution of the Bug are analyzed

Code Review
Type:
Formal review
Informal Lookup
Self-Check
Cross-check
Four-eye Lookup
Meeting Inspection

Possible issues in code review:
Code Specification
Typographical
Name
Note
Design Requirements
Whether the encoding meets the design and requirements

Code review policy
Daily/weekly check
Required for beginners
Core code required

How to Ensure code review results
Introduce code static check tools
Use the code review checklist
The checklist must be updated and maintained.
Checklist data statistics
Programming Skills
Experience
Training
Guidance
Benchmark

Reconstruction [unit test cases are the guarantee of reconstruction]
Definition: Adjust the program structure without changing the external behavior of the software to improve comprehensibility and maintainability
Optimize Software Structure
Locate bugs
Reconstruction time:
When modifying a bug
Code Review
When adding new features