At Greptile, we understand that quickly identifying and addressing software bugs is crucial for building reliable, secure, and performant software. To help developers navigate common pitfalls, we've created a comprehensive Bug Wiki. This resource provides clear explanations, examples, and categorization of common software bugs.
Explore our categorized bug directory below:
Logic & Control Flow Bugs
Errors in conditional statements, loops, and program logic that cause unexpected behavior
- Array index out of bounds: Program accesses invalid array indexes, causing crashes or errors.
- Buffer overflow: Data exceeds allocated memory, risking crashes or security issues.
- Divide by zero: Attempted division using zero, causing runtime errors or crashes.
- Uninitialized variable: Variable used without an assigned value, causing unpredictable behavior.
- Variable shadowing: Inner variable hides an outer one, leading to confusion or bugs.
- Unreachable code: Code segment that can never execute, wasting resources.
- Integer overflow: Integer exceeds the maximum allowed value, leading to incorrect results.
- Integer underflow: Integer drops below the minimum allowed value, causing unexpected behavior.
- Loss of precision: Numeric data precision lost during calculations, causing errors.
- Incorrect assignment: Value incorrectly assigned, causing unintended outcomes.
- Logic error: Logical mistake resulting in incorrect outcomes.
- Incorrect operator precedence: Operators evaluated in the wrong order, causing logical errors.
- Off-by-one error: Calculation errors from loop or array indexes off by one.
State & Data Consistency
Issues with application state management and data integrity across systems
- Broken image: Image fails to load, resulting in broken visuals.
- Broken link: Link directs users to a non-existent or incorrect page.
- Inconsistent UI state: UI displays conflicting or incorrect information.
- Incorrect pagination: Pages incorrectly ordered or divided, disrupting navigation.
- Circular dependency: Components depending on each other create a dependency loop.
- Data truncation: Data unintentionally cut short due to storage limits.
- Duplicate key error: Duplicate entry violates database uniqueness constraints.
- Lost update: Concurrent updates overwrite each other unintentionally.
- Orphaned record: Record disconnected from related database entries.
- Stale cache: Serving outdated data due to caching issues.
- Incomplete migration: Data migration partially executed, causing inconsistencies.
- API versioning: Issues arise due to incompatible API versions.
- Inconsistent naming: Inconsistent naming causes confusion and maintainability issues.
- Inconsistent state: Component in unexpected state, causing unreliable behavior.
Security & Access Control
Vulnerabilities and security flaws that expose systems to unauthorized access
- SQL injection: Malicious input injected into database queries, posing security risks.
- Command injection: Malicious commands injected via user input fields.
- Hardcoded credentials: Credentials embedded directly into source code, risking security.
- Hardcoded timestamp: Explicit timestamp coded, causing incorrect date/time data.
- Information disclosure: Sensitive information exposed unintentionally.
- Missing rate limiting: Request frequency limits missing, risking overload or abuse.
- Path traversal: Unauthorized directory access via manipulated paths.
- Privilege escalation: Unauthorized elevation of user privileges.
Memory & Resource Management
Problems with memory allocation, leaks, and system resource utilization
- Zombie process: Finished processes incorrectly show as active, causing resource leaks.
- Orphaned process: Process continues running after parent process ends, consuming resources.
- Memory corruption: Memory unintentionally modified, causing instability or crashes.
- Memory fragmentation: Free memory becomes fragmented, reducing efficiency.
- Memory leak: Unused memory accumulates without proper release.
- Resource contention: Multiple processes compete for the same limited resources simultaneously.
- Resource exhaustion: System resources fully consumed, causing failures.
- Resource leak: Resources remain allocated after use, causing inefficiencies.
- Stack overflow error: Call stack exceeds limit, causing crashes or halts.
- Null pointer dereference: Null references accessed, causing runtime exceptions.
- Orphaned resource: Allocated resource not tracked or released, causing leaks.
Error Handling & Validation
Missing or improper error handling and input validation mechanisms
- Incorrect MIME type: Resource served with incorrect MIME type causing rendering issues.
- Missing alt text: Image missing descriptive alternative text, hurting accessibility and SEO.
- Incorrect permissions: User unintentionally has access to restricted resources.
- Unhandled exception: Exceptions occur without proper handling, causing crashes.
- Incorrect exception handling: Improper exception handling leading to instability or errors.
- Incorrect file path: Incorrect file location specified, causing file access errors.
- Logic inversion: Logical conditions mistakenly reversed, causing unintended logic.
- Missing default case: Switch statement missing fallback option, causing potential errors.
- Missing dependency: Essential component or library missing, causing runtime errors.
- Missing error handling: Errors occur without proper handling, leading to crashes.
- Missing null check: Failure to verify null values, causing runtime exceptions.
- Missing test coverage: Code paths not adequately covered by tests.
- Syntax error: Code incorrectly written, causing compilation or runtime errors.
- Implicit type coercion: Automatic type conversions causing unexpected behaviors.
- Invalid enum value: Enum set to an invalid or unintended value.
- Incorrect timestamp: Incorrect or improperly formatted timestamp, causing errors.
Code Quality & Redundancy
Code maintenance issues including unused code, poor naming, and redundancy
- Redundant code: Repeated code unnecessarily bloating the codebase.
- Unused import: Imported module never utilized, causing unnecessary dependencies.
- Unused variable: Declared variable unused, leading to wasted resources.
- Excessive logging: Excessive logging statements causing performance or readability issues.
- Incorrect log level: Incorrect logging severity chosen, causing confusion.
- Incorrect import path: Incorrect file or module path in import statement, causing build errors.
- Incorrect string interpolation: Variables incorrectly formatted within strings.
- Incorrect escaping: Special characters improperly escaped, causing display issues.
- Incorrect normalization: Data incorrectly standardized or formatted, causing processing errors.
Async & Event Handling
Concurrency issues, race conditions, and asynchronous programming bugs
- Duplicate request: Same request sent multiple times unintentionally.
- Data race: Concurrent threads improperly accessing shared data.
- Deadlock: Processes permanently stuck waiting on each other, halting execution.
- Race condition: Program outcome depends unpredictably on event timing.
- Infinite loop: Loop continuously runs without ending, freezing the system.
- Infinite recursion: Recursive function calls itself indefinitely, causing stack overflow.
- Flaky test: Test produces inconsistent, unpredictable results.
- Unhandled promise: Promises without proper handling, causing silent failures.
- Unhandled promise rejection: Promise rejections not handled, causing runtime issues.
- Missed event: Expected event not captured or handled properly.
How Greptile Detects These Bugs
Greptile’s AI code reviews successfully identified every bug highlighted in our directory, demonstrating the how a code review tool can help catch bugs before they reach production. Check out the examples provided under each bug to view the original code submitted in a pull request, along with Greptile's catch before the issue was merged into prod.
By thoroughly understanding each bug category, Greptile empowers developers to proactively prevent errors, maintain high-quality codebases, and deliver more reliable and secure software.