Greptile Bug Wiki

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.