4. előadás: Statikus analízis, ciklomatikus komplexitás

Overview of Testing in Software Development

Introduction to Testing Concepts

• The discussion begins with a recap of the previous week's focus on static and dynamic testing, particularly in the context of SonarQube's testing pipeline.

• Emphasis is placed on lexical analysis as the first step, which involves verifying that tokenized code meets specific expectations regarding function names, variable names, and formatting.

Syntax Analysis

• The next phase is syntax analysis, where the entire structure of code blocks is examined to ensure compliance with syntactical rules.

• Examples include ensuring single-line statements are enclosed in parentheses and that switch statements contain a default case.

Control Flow Analysis

• Control flow analysis follows syntax checks; its purpose is to identify unreachable code and other properties within the codebase.

• This section transitions into discussing control flow graphs (CFG), which represent source code as a graph with entry and exit points.

Understanding Control Flow Graphs

• A CFG consists of nodes representing instructions and edges indicating possible execution paths. It aims to document all potential control paths through the program.

• The speaker illustrates this concept using Java examples, explaining how instructions can be traced through various states during execution.

Practical Application of Control Flow Analysis

• The discussion includes practical scenarios where multiple instructions are executed sequentially, highlighting how CFG can simplify understanding complex logic flows.

• An example involving conditional statements demonstrates how branching affects execution paths based on comparisons made within the code.

Detailed Example Walkthrough

• A detailed breakdown follows for a loop structure (for loop), illustrating how each iteration leads to different outcomes based on conditions evaluated at runtime.

Control Flow Analysis in Programming

Understanding Control Flow Graphs

• The discussion begins with the concept of a control flow graph, which illustrates how different paths in code execution are determined based on conditions (e.g., if statements).

• The purpose of control flow analysis is to identify accessible paths within the code and understand potential execution routes from a given starting point.

• It is noted that certain instructions may not be reachable due to conditional branches, leading to parts of the code being effectively unused or redundant.

• A trivial example is provided where an if statement leads to a return, indicating that some lines of code may never execute depending on the conditions set.

• The speaker emphasizes that understanding these unreachable sections can help identify unnecessary or poorly structured code.

Identifying Redundant Code

• The control flow graph shows entry and exit points, highlighting how certain nodes (or instructions) may not be reached during execution.

• Unreachable code segments indicate potential issues in logic or structure, suggesting that developers might have overlooked necessary conditions for execution.

• Common pitfalls include writing complex conditionals without realizing they lead to dead ends in the program's logic, resulting in wasted effort and resources.

• Static analysis tools can flag unreachable code as errors, prompting developers to review their logic and ensure all intended paths are valid and necessary.

• Developers should consider simplifying their conditions; if certain branches are unnecessary, they can remove them entirely for cleaner code.

Importance of Return Statements

• Modern programming languages often require functions to have return statements for every possible path; failing this results in compilation errors or warnings about missing returns.

• If both branches of an if statement contain return statements, compilers recognize that all paths lead to an exit point, thus avoiding errors related to missing returns.

• Control flow analysis has been integrated into compilers for years but has recently become more accessible through development environments and plugins for better static analysis capabilities.

Conclusion: Enhancing Code Quality Through Analysis

Understanding Control Flow and Condition Handling in Programming

The Importance of Code Validity

• A binary code must be valid for execution; however, quality control may reject valid Java or C++ code if it cannot run under any circumstances. This highlights the need to maintain a clean codebase.

Exploring Conditional Statements

• The discussion shifts to handling conditions in programming, emphasizing the importance of evaluating conditional checks effectively.

Analyzing Complex Conditions

• A complex condition is presented involving multiple function calls that return boolean values. The focus is on visualizing the control flow graph based on these conditions.

Evaluating Control Flow Graphs

• When checking an 'if' statement, the first instruction executed involves evaluating a large condition. This requires understanding how each function call contributes to the overall logic.

Decision Points in Control Flow

• The next step depends on whether a decision point evaluates as true or false, leading to different paths in the control flow graph. This illustrates how branching logic operates within programming structures.

Function Call Dependencies

• If a condition evaluates as false, alternative functions are called (e.g., test 2). Understanding these dependencies is crucial for predicting program behavior.

Identifying Redundant Code Paths

• It becomes evident that certain function calls may lead to redundant paths within the control flow graph. Recognizing this can help optimize code efficiency.

Static vs Dynamic Analysis Techniques

• Static analysis may not detect all redundancies in code; however, data flow analysis can identify identical operations across different parts of the program, potentially flagging them as warnings during development.

Optimization Opportunities

• Developers should be aware of opportunities for optimization when similar expressions are detected within their coding environment. Tools often provide feedback about potential redundancies.

Side Effects and Parameter Changes

Understanding Control Flow Graphs and Cyclomatic Complexity

Overview of Functionality and Side Effects

• The function checks if an array is sorted; if not, it deletes the first element that violates the order. If only one such element exists, the first call returns a value indicating failure, while subsequent calls will succeed.

• Modifying parameter values can lead to side effects; for instance, using a global variable or a class member variable can affect how the code behaves without clear visibility.

Control Flow Graph (CFG)

• A control flow graph is associated with complex conditions in code. It visually represents how different paths through the code are structured.

• CFGs serve two main purposes: detecting unreachable code and assessing code complexity.

Cyclomatic Complexity

• Cyclomatic complexity is defined as a metric used to measure the number of linearly independent paths through a program's source code.

• A simple algorithm typically has one entry point and one exit point, leading to straightforward execution without branching complexities.

Measuring Complexity

• The goal is to determine how many distinct paths exist from entry to exit in a given piece of code.

• More complex algorithms may introduce additional pathways that need evaluation for their impact on overall complexity.

Path Counting and Infinite Loops

• The cyclomatic complexity counts independent control paths between entry and exit points in the program.

• If loops are present, they complicate path counting since executing them multiple times does not create new unique paths but rather leads to infinite possibilities.

Calculating Cyclomatic Complexity

• To calculate cyclomatic complexity accurately, it's essential to consider edges (E), nodes (N), and connected components (P).

• The formula for cyclomatic complexity is C = E - N + 2P. This formula helps quantify the structural complexity of programs effectively.

Example Application of Formula

• In practical examples, applying this formula reveals insights into program structure; for instance:

• For simple cases: E = 3 edges, N = 4 nodes, P = 1 component results in C = 3 - 4 + 2(1) = 1.

Cyclic Complexity and Component Analysis

Overview of Components and Complexity

• The speaker discusses the difficulty in counting components, noting that there are 11 nodes but only 7 connected components. This indicates a complex structure within the graph.

• It is highlighted that having two separate components in modern code is rare unless dealing with large applications or APIs with multiple entry points.

• The complexity formula is introduced: number of edges (11) minus number of vertices (7), plus 2, leading to a calculated complexity of 6.

Independent Paths in Graphs

• The speaker examines the existence of independent paths within the graph, identifying at least four distinct routes based on traversal patterns.

• There’s a discussion about whether cycles are included or excluded from these paths, raising questions about potential miscalculations in the graph's structure.

Cyclomatic Complexity Calculation

• A need for clarification arises regarding why the cyclomatic complexity does not equal eight; this will be addressed later with further analysis.

• The concept of quality gates is introduced, emphasizing that code should not exceed a certain complexity threshold (typically seven or eight).

Managing High Cyclomatic Complexity

• When encountering high cyclomatic complexity in methods, developers must refactor their code to reduce it effectively.

• An example illustrates how branching logic complicates code and suggests isolating complex sections into separate methods to enhance clarity.

Adjusting Graph Structure for Clarity

• The speaker proposes adding an additional node to modify an edge without changing overall complexity significantly.

• By introducing new nodes while maintaining existing connections, the overall component count remains unchanged despite adjustments made to edges.

Strategies for Reducing Cyclomatic Complexity

• Suggestions include consolidating multiple nodes into single instructions or methods to streamline processes and reduce complexity metrics.

• Further exploration into restructuring graphs reveals potential reductions in edge counts through strategic node consolidation.

Understanding Cyclomatic Complexity and Code Refactoring

Reducing Cyclomatic Complexity

• The speaker discusses the importance of refactoring code to reduce cyclomatic complexity by transforming certain sections into methods, which can lower the number of edges and nodes in a control flow graph.

• A well-organized code structure allows for effective encapsulation of loops into functions, thereby simplifying the overall complexity. This is illustrated with an example involving three nested loops.

• The speaker emphasizes that if the original code lacks clear entry and exit points, it becomes difficult to manage or improve, indicating poor design.

Challenges in Code Structure

• The discussion highlights issues with unreachable code segments within exception handling blocks, suggesting that developers may overlook potential exceptions during coding.

• An exercise is proposed where participants should attempt to draw a detailed control flow graph based on their understanding of cyclomatic complexity and its implications on code readability.

Control Flow Graph Analysis

• The speaker explains how modifications to a control flow graph can maintain or even improve its complexity metrics while ensuring clarity in representation.

• By merging sequential instructions into single nodes within the graph, one can effectively reduce node count without increasing complexity, demonstrating efficient coding practices.

Merging Nodes for Clarity

• The process of combining consecutive instructions is discussed as a method to streamline graphs; this reduces both node and edge counts while preserving logical integrity.

• It’s noted that maintaining smaller graphs aids in analysis since large graphs complicate understanding due to excessive branching and paths.

Practical Application of Concepts

• Examples are provided illustrating how specific instructions can be merged into singular nodes for better clarity in complex structures like loops or conditionals.

• The speaker clarifies misconceptions about loop execution order and emphasizes accurate representation when drawing control flow diagrams for better comprehension among developers.

Conclusion on Cyclomatic Complexity

Static Code Analysis and Data Flow Analysis

Static Code Analysis Overview

• The discussion begins with a focus on static code analysis, highlighting potential issues related to cyclic dependencies in the code.

• It is noted that the next step after completing static analysis is to delve into data flow analysis.

Data Flow Analysis Introduction

• Data flow analysis aims to track which instructions can lead to others, focusing on how data moves through the program.

• The primary goal of data flow analysis is to determine where specific data can reach and what modifications can occur.

Key Concepts in Data Flow Analysis

• Important aspects include detecting uninitialized variables and unused variables, as well as identifying memory leaks and overflow conditions.

• The process involves tracking data movement within the program, allowing for various detections regarding variable usage.

Practical Application of Data Flow Analysis

• A practical example illustrates how data flow analysis works by assigning labels to generated data from instructions.

• For instance, if x = 6 is executed, it generates a label for this value (data 1), while subsequent operations build upon this initial assignment.

Instruction Tracking and Variable Accessibility

• As calculations proceed (e.g., calculating y based on x), each instruction's output receives a unique identifier for tracking purposes.

• The discussion emphasizes how certain variables become inaccessible due to overwriting during execution; thus, understanding variable scope is crucial.

Advanced Insights into Variable Usage

• Analyzing which instructions require specific data helps clarify dependencies between them.

• Ideally, a comprehensive data flow analysis would maintain records of all possible values for each variable throughout its lifecycle.

Limitations and Challenges in Data Flow Analysis

• There are inherent limitations in capturing every possible state due to finite resources; thus, tools often simplify their approach by focusing on reachable variables rather than exhaustive tracking.

• Identifying whether a variable has been utilized effectively allows developers to optimize code by removing unnecessary declarations or assignments.

Code Analysis and Variable Management

Iterative Variable Analysis

• The discussion begins with the concept of iterative analysis, where unused variables (like x, y, or z) are identified and removed from the code to streamline functionality.

• It is emphasized that a smart environment can determine which variables are unnecessary, suggesting an automated process for cleaning up code by eliminating unused variables.

Handling Data Types and Null Values

• The speaker introduces the idea of analyzing different data types, particularly focusing on how null values can complicate operations like division.

• A conditional structure (if statement) is proposed to handle cases where a variable may be null, allowing for more controlled execution paths in the code.

Static Code Analysis Techniques

• Various technologies exist to analyze branching in code, helping developers understand potential outcomes based on variable states without testing every possible value.

• The importance of static code analyzers is highlighted; they can track variable states effectively unless overly complex operations obscure their tracking ability.

Advantages of Strongly Typed Languages

• The speaker expresses a preference for strongly typed languages in large projects due to their ability to provide critical type information that aids static analysis.

• While acknowledging that dynamic coding might be faster for quick demos, the long-term benefits of type safety and clarity in larger applications are underscored.

Metrics-Based Code Analysis

• Transitioning into metrics-based analysis, various metrics such as function length and cyclomatic complexity are introduced as tools for evaluating code quality.

• These metrics help identify patterns within the codebase, including potential issues like duplicated code segments through control flow graphs.

Identifying Code Duplication

• Control flow graphs can reveal duplicated sequences within the code, prompting discussions about functional versus structural duplication detection methods.

• Algorithms designed for pattern recognition within graphs can assist in identifying repeated structures or sequences across different parts of the codebase.

Singleton Patterns and Common Programming Mistakes

Issues with Singleton Initialization

• A singleton pattern can become problematic if initialized asynchronously, as it may not be ready when accessed. This indicates a potential flaw in the implementation.

Common Programming Errors

• Many programmers make significant mistakes, with a notable collection of around 100 common errors that are easily identifiable through metrics-based analysis.

Metrics-Based Analysis Process

• After running metrics-based analyses, various metrics are collected for further evaluation. The next steps involve pattern matching to identify suspicious code segments.

Pattern Matching in Code

• Pattern matching involves identifying specific code snippets that may indicate poor practices, such as hardcoded strings for sensitive data like passwords.

• For example, having a hardcoded password string is a red flag; ideally, such values should be retrieved from functions or configuration files instead of being statically assigned.

SQL Injection Risks

• If an SQL command is constructed using string concatenation without proper sanitization, it poses a risk for SQL injection attacks. This can be detected through pattern-based analysis.

Deprecated Function Calls and Security Analysis

• Pattern analyses can also detect deprecated function calls within libraries. These analyses highlight outdated methods that should no longer be used due to security vulnerabilities.

• Security analysis works similarly to pattern-based analysis but focuses on identifying known vulnerabilities associated with outdated library versions or insecure coding practices.

Importance of Static Code Analysis Tools

• Running static code analysis tools can reveal security vulnerabilities even if no changes were made to the codebase since previous checks.

• Tools like SonarQube provide extensive lists of common programming errors and their solutions, helping developers understand issues like unnecessary increments or improper return types in methods.

Static Code Analysis and Best Practices

Importance of Static Analysis in Development

• The speaker emphasizes the significance of understanding how to properly implement static analysis tools, highlighting that they can help developers learn from mistakes and improve coding practices.

• A warning system integrated into the development environment alerts developers about potential issues, allowing them to correct mistakes before code review, thus maintaining quality standards.

• Ignoring warnings can lead to poor coding practices being noted by colleagues during code reviews, which underscores the importance of addressing these alerts proactively.

• Quality gates can be established to prevent certain types of errors (like linting issues) from being committed, ensuring a higher standard of code quality is maintained throughout development.

• The balance between strictness in coding standards and practical development needs is discussed; overly strict rules may hinder progress while still allowing for necessary corrections post-commit.

Transitioning to Dynamic Testing Methods