defects.json

{
    "defects": [
        {
            "defect name": "duplicate block",
            "id": "2",
            "description": "Two very similar blocks of code.",
            "code example": "if c:\n    f(1)\n    g(1)\n    f(1)\nelse:\n    f(2)\n    g(2)\n    f(2)",
            "code fix example": "def fun(n):\n    f(n)\n    g(n)\n    f(n)\n\nif c:\n    fun(1)\nelse:\n    fun(2)",
            "prog. concept": "function",
            "defect type": "duplicate code"
        },
        {
            "defect name": "duplicate expression",
            "id": "1",
            "description": "Repeated occurences of the same (complex) expression.",
            "code example": "if numbers[n//2] % 2 >= 0:\n   print(numbers[n//2] % 2)",
            "code fix example": "val = numbers[n//2] % 2\nif val >= 0:\n   print(val)",
            "prog. concept": "variable",
            "defect type": "duplicate code"
        },
        {
            "defect name": "one-letter name",
            "id": "3",
            "description": "One-letter variable name (with several exceptions like i, j, and n).",
            "code example": "l = 4",
            "code fix example": "length = 4",
            "prog. concept": "variable",
            "defect type": "poor name"
        },
        {
            "defect name": "redundant if-else",
            "id": "4",
            "description": "If-else statement with both branches being return True/False.",
            "code example": "if c:\n    return True\nelse:\n    return False",
            "code fix example": "return c",
            "prog. concept": "condition",
            "defect type": "simplifiable"
        },
        {
            "defect name": "all if branches start/end with identical code",
            "id": "13",
            "description": "All if/elif/else branches start or end with the same code, which can be moved before or after the block.",
            "code example": "if cond:\n    print(\"foo\")\n    i += 1\nelse:\n    print(\"bar\")\n    i += 1",
            "code fix example": "if cond:\n   print(\"foo\")\nelse:\n   print(\"bar\")\ni += 1",
            "prog. concept": "condition",
            "defect type": "duplicate code"
        },
        {
            "defect name": "misleading name",
            "id": "11",
            "description": "Variable name i or j used when traversing items, not indices.",
            "code example": "for i in text:\n    print(i)",
            "code fix example": "for letter in text:\n    print(letter)",
            "prog. concept": "loop",
            "defect type": "poor name"
        },
        {
            "defect name": "no early return",
            "id": "9",
            "description": "The code contains a condition that executes long piece of code in the positive branch and a short one in the negative one.",
            "code example": "if cond:\n    # long code\nelse:\n    return 0",
            "code fix example": "if not cond:\n    return 0\n# long code",
            "prog. concept": "condition",
            "defect type": "poor design"
        },
        {
            "defect name": "redundant variable/attribute",
            "id": "12",
            "description": "The code contains two variables/attributes, where one can be cheaply computed from the other.",
            "code example": "depth = 0\nprefix = \"\"\n# code using depth and prefix\ndepth += 1\nprefix += \"    \"",
            "code fix example": "depth = 0\n# code using depth and\n# \" \" * 4 * depth\n# instead of prefix\ndepth += 1",
            "prog. concept": "variable",
            "defect type": "poor design"
        },
        {
            "defect name": "trivial comment",
            "id": "10",
            "description": "The code contains trivial comment directly corresponding to the statement.",
            "code example": "x += 1  # increase value by 1",
            "code fix example": "x += 1",
            "prog. concept": "multiple",
            "defect type": "poor documentation"
        },
        {
            "defect name": "while as for",
            "id": "7",
            "description": "While loop with the number of iterations known before its start.",
            "code example": "i = 0\nwhile i <= n:\n    print(i)\n    i += 1",
            "code fix example": "for i in range(n):\n    print(i)",
            "prog. concept": "loop",
            "defect type": "unsuited construct"
        },
        {
            "defect name": "nested if",
            "id": "16",
            "description": "Nested if-statements avoidable using conjunction (e.g., when the last branch is single if).",
            "code example": "if c1:\n    if c2:\n        # body",
            "code fix example": "if c1 and c2:\n   # body",
            "prog. concept": "condition",
            "defect type": "simplifiable"
        },
        {
            "defect name": "using global variables",
            "id": "14",
            "description": "The code unnecessarily uses global variables.",
            "code example": "# no example here as we did not find a concise one",
            "code fix example": "",
            "prog. concept": "variable",
            "defect type": "poor design"
        },
        {
            "defect name": "unused variable",
            "id": "19",
            "description": "Variable that is defined but never read.",
            "code example": "y = 4\nprint(4)",
            "code fix example": "print(4)",
            "prog. concept": "variable",
            "defect type": "unused"
        },
        {
            "defect name": "augmentable assignment",
            "id": "27",
            "description": "Variable update expressible as augmented assignment.",
            "code example": "x = x + 4",
            "code fix example": "x += 4",
            "prog. concept": "expression",
            "defect type": "simplifiable"
        },
        {
            "defect name": "long line",
            "id": "25",
            "description": "Line with more than 100 characters.",
            "code example": "income = (gross_wages + taxable_interest + (dividends - qualified_dividends) - ira_deduction - student_loan_interest)",
            "code fix example": "income = (gross_wages\n          + taxable_interes\n          + (dividends - qualified_dividends)\n          - ira_deduction\n          - student_loan_interest)",
            "prog. concept": "multiple",
            "defect type": "poor formatting"
        },
        {
            "defect name": "block with no effect",
            "id": "34",
            "description": "An if statement or loop has no effect.",
            "code example": "for number in [1, 2, 3]:\n    break",
            "code fix example": "remove the code",
            "prog. concept": "multiple",
            "defect type": "unused"
        },
        {
            "defect name": "using known value as variable",
            "id": "36",
            "description": "The code uses an expression which was already tested for a specific value.",
            "code example": "if len(lst1) == 0:\n    print(lst2[len(lst1)])",
            "code fix example": "if len(lst1) == 0:\n    print(lst2[0])",
            "prog. concept": "expression",
            "defect type": "simplifiable"
        },
        {
            "defect name": "negated condition with else clause",
            "id": "37",
            "description": "The code contains an if statement with an else branch, whose condition is negated.",
            "code example": "if not cond:\n     # body 1\nelse:\n     # body 2",
            "code fix example": "if cond:\n    # body 2\nelse:\n    # body 1",
            "prog. concept": "condition",
            "defect type": "simplifiable"
        },
        {
            "defect name": "long function",
            "id": "38",
            "description": "Function with more than 20 statements.",
            "code example": "def f():\n    ... # > 20 statements",
            "code fix example": "decompose the function",
            "prog. concept": "function",
            "defect type": "poor design"
        },
        {
            "defect name": "unnecessary else/elif",
            "id": "39",
            "description": "Redundant use of else after command when the positive branch uses return/break/continue.",
            "code example": "if c:\n    return val1\nelse:\n    return val2",
            "code fix example": "if c:\n    return val1\nreturn val2",
            "prog. concept": "condition",
            "defect type": "simplifiable"
        },
        {
            "defect name": "using non-English identifiers",
            "id": "41",
            "description": "The code uses function or variable names that are not in English.",
            "code example": "promenna = 28",
            "code fix example": "variable = 28",
            "prog. concept": "variable",
            "defect type": "poor name"
        },
        {
            "defect name": "inconsistent names",
            "id": "42",
            "description": "Functions with similar purpose have names using different naming schemes.",
            "code example": "validate_pair\ntuple_validation",
            "code fix example": "validate_pair\nvalidate_tuple",
            "prog. concept": "function",
            "defect type": "poor name"
        },
        {
            "defect name": "unused import",
            "id": "45",
            "description": "Module is imported but unused.",
            "code example": "import math\nprint(max(3, 4))",
            "code fix example": "print(max(3, 4))",
            "prog. concept": "module",
            "defect type": "unused"
        },
        {
            "defect name": "redundant arithmetic",
            "id": "48",
            "description": "Identity operation or constant-valued expression.",
            "code example": "1*x, x/x",
            "code fix example": "x, 1.0",
            "prog. concept": "expression",
            "defect type": "simplifiable"
        },
        {
            "defect name": "too many arguments",
            "id": "50",
            "description": "The function has too many arguments.",
            "code example": "def move(board, x, y, dir_x, dir_y, color):\n   # body",
            "code fix example": "def move(board, position, direction, color):\n    # body",
            "prog. concept": "function",
            "defect type": "poor design"
        },
        {
            "defect name": "local variable used only to return",
            "id": "53",
            "description": "The code uses a local variable that is only used in a return statement.",
            "code example": "def some_function():\n    some_value = 1\n    return some_value",
            "code fix example": "def some_function():\n    return 1",
            "prog. concept": "function",
            "defect type": "simplifiable"
        },
        {
            "defect name": "redundant not",
            "id": "60",
            "description": "Boolean expression with negation that can be simply applied.",
            "code example": "not a <= b",
            "code fix example": "a > b",
            "prog. concept": "expression",
            "defect type": "simplifiable"
        },
        {
            "defect name": "absolute value",
            "id": "71",
            "description": "Compound condition equivalent to a single condition with absolute value.",
            "code example": "x < 4 and x > -4",
            "code fix example": "abs(x) < 4",
            "prog. concept": "expression",
            "defect type": "unsuited construct"
        },
        {
            "defect name": "missing docstring",
            "id": "67",
            "description": "A function, class, or method is missing a docstring.",
            "code example": "",
            "code fix example": "add the docstring",
            "prog. concept": "multiple",
            "defect type": "poor documentation"
        },
        {
            "defect name": "argument does not come first in comparison",
            "id": "77",
            "description": "A code uses a comparison where a constant comes first and a variable only second.",
            "code example": "if 3 < some_x:",
            "code fix example": "if some_x > 3:",
            "prog. concept": "expression",
            "defect type": "poor formatting"
        }
    ]
}