Tell about features of static analysis.

Static code analysis is a technique for analyzing code without executing the program.

Features:

1. Early defect detection: Allows finding errors related to syntax, typing, potential memory leaks, uninitialized variables, dead code during writing or compilation, before running the application.
2. Low cost: Detecting and fixing defects at the coding stage is significantly cheaper than at later stages of the development lifecycle.
3. Code coverage: The analysis covers all branches of the code, including rarely executed ones, which might be missed during dynamic testing.
4. Detection of potential vulnerabilities: Can identify common security vulnerabilities (e.g., SQL injections, XSS) based on code structure analysis.
5. Code quality control: Helps ensure compliance with coding standards, naming rules, function complexity, and other quality metrics.
6. Integration with CI/CD: Easily integrates into continuous integration/deployment pipelines for automatic code checks on each change.
7. Limitations:
   • Does not find all defects: Does not identify errors related to program logic, interaction with external systems, performance, or incorrect behavior during execution.
   • Can produce false positives: Sometimes marks correct code as problematic. Requires manual verification of results.
   • Depends on the quality of tools: The effectiveness of analysis heavily depends on the chosen tools and their configurations.
8. Types of analysis:
   • Syntax and structure control.
   • Control Flow Analysis.
   • Data Flow Analysis.
   • Code metrics evaluation.
   • Detection of common errors and vulnerabilities.

Examples of use:

• Checking code compliance with standards (e.g., PEP 8 for Python, SonarQube rules).
• Finding unused variables or functions.
• Detecting potential null-pointer exceptions.
• Analyzing code complexity.

# Example of simple code for analysis
def calculate_sum(a, b):
    # Usage of uninitialized variable (potentially)
    # result = a + b + c 
    result = a + b # Correct usage
    return result

def unused_function():
    # This function is not called
    print("This function is not used")

x = 5
y = 10
print(calculate_sum(x, y))

Static analysis is an important part of quality assurance strategy and helps improve code reliability and maintainability.