Asserting Compliance with Styling and Layout Guides

🏷️ Final Capstone Engineer Script project / Code Review Checklist

📚 All-in-One📖 Theory Only💻 Code Only

📝 Context Introduction

When reviewing code, one of the first things to check is whether the code follows consistent styling and layout rules. Styling and layout compliance ensures that code is readable, maintainable, and adheres to team or project standards. For engineers who are new to code reviews, understanding how to verify compliance with guides like PEP 8 (for Python) or project-specific style guides is essential. This section covers how to assert that code meets these expectations during a review.

⚙️ Why Styling and Layout Compliance Matters

Readability: Consistent indentation, spacing, and line length make code easier to scan and understand.
Maintainability: When all code follows the same rules, it reduces cognitive load for future engineers.
Automation Compatibility: Many tools (like linters) enforce these rules automatically, catching issues early.
Professionalism: Clean, consistent code reflects attention to detail and respect for the team.

🕵️ Key Areas to Check for Compliance

Indentation: Use 4 spaces per indentation level. Never mix tabs and spaces.
Line Length: Keep lines under 79 characters for code and 72 for docstrings or comments.
Blank Lines: Use two blank lines before top-level definitions (classes and functions) and one blank line before method definitions inside a class.
Imports: Group imports in the order: standard library, third-party, local application. Separate each group with a blank line.
Whitespace: Avoid extra spaces inside parentheses, brackets, or braces. Use a single space around operators and after commas.
Naming Conventions: Use snake_case for variables and functions, PascalCase for classes, and UPPER_CASE for constants.

🛠️ How to Assert Compliance During a Code Review

Manually inspect the code for obvious violations like inconsistent indentation or missing blank lines.
Run a linter such as flake8 or pylint against the codebase. These tools flag violations automatically.
Check configuration files like setup.cfg or .flake8 to confirm the project's specific style rules.
Compare against the project's style guide if one exists (e.g., a CONTRIBUTING.md or style guide document).
Use automated CI/CD checks that enforce styling rules before code is merged.

📊 Comparison Table: Common Style Violations vs. Compliant Code

Violation Example	Compliant Example	Explanation
No blank line after import	One blank line after imports	Separates imports from code logic
Line exceeds 100 characters	Line broken at 79 characters	Improves readability in editors and terminals
Mixed tabs and spaces	Consistent 4-space indentation	Avoids syntax errors and alignment issues
Extra spaces inside parentheses	No spaces inside parentheses	Follows PEP 8 spacing rules
Function name in CamelCase	Function name in snake_case	Matches Python naming conventions

✅ Final Checklist for Styling and Layout Compliance

[ ] Indentation uses 4 spaces consistently
[ ] No lines exceed the project's maximum line length
[ ] Imports are grouped and ordered correctly
[ ] Blank lines are used appropriately between definitions
[ ] Whitespace is minimal and consistent
[ ] Naming conventions match the project's style guide
[ ] Linter passes without styling violations
[ ] No tabs are used in place of spaces

By following these guidelines, engineers can confidently assert that code complies with styling and layout standards during a review. This practice leads to cleaner, more professional codebases that are easier for everyone to work with.

This file shows how to check that your Python code follows style rules like indentation, line length, naming conventions, and blank line spacing.

✅ Example 1: Checking indentation consistency

This example shows how Python enforces consistent indentation using spaces.

def calculate_area():
    length = 10
    width = 5
    area = length * width
    return area

result = calculate_area()
print(result)

📤 Output: 50

✅ Example 2: Verifying line length compliance

This example shows how to keep lines under 79 characters for readability.

# Long line broken into two shorter lines
total = (100 + 200 + 300 + 400 + 500 + 600 + 700
         + 800 + 900 + 1000)
print(total)

📤 Output: 5500

✅ Example 3: Checking variable naming conventions

This example shows proper snake_case naming for variables and functions.

def get_user_name(user_id):
    first_name = "Alice"
    last_name = "Smith"
    full_name = first_name + " " + last_name
    return full_name

user_full_name = get_user_name(101)
print(user_full_name)

📤 Output: Alice Smith

✅ Example 4: Verifying blank line spacing between functions

This example shows two blank lines required between top-level functions.

def first_function():
    return "Function one"


def second_function():
    return "Function two"


print(first_function())
print(second_function())

📤 Output: Function one
📤 Output: Function two

✅ Example 5: Checking import order compliance

This example shows standard library imports before third-party imports.

import math
import os
import sys

import numpy
import pandas

radius = 5
area = math.pi * radius ** 2
print(area)

📤 Output: 78.53981633974483

Comparison Table: Common Style Rules and How to Check Them

Style Rule	What to Look For	How to Verify
Indentation	4 spaces per level	Count spaces before code
Line length	Maximum 79 characters	Count characters per line
Naming convention	snake_case for variables/functions	Check for underscores between words
Blank lines	2 blank lines between functions	Count empty lines in code
Import order	Standard library first, then third-party	Check import statement sequence