Debugging Language

Core debugging vocabulary: reproduce (make the bug happen again), intermittent (happens occasionally, not every time), race condition (timing-dependent bug), regression (bug introduced by a recent change), root cause (underlying cause, not just the symptom), workaround (temporary fix), stack trace (error call chain), breakpoint (pause for inspection), step through (execute line by line), null pointer / undefined (accessing non-existent value).

Clear bug description format: (1) What happened ("When I click Submit, the page goes blank"); (2) What I expected ("The form should submit and show a success message"); (3) Steps to reproduce (numbered, specific); (4) Environment (browser, OS, version); (5) Frequency ("always" / "intermittent — about 1 in 5 times"); (6) Error message if any. A description with these six elements reduces debugging time significantly.

Collaborative debugging phrases: "I've narrowed it down to the authentication layer", "It looks like the issue is in the database query — I can see unexpected NULL values", "Can you reproduce it with this minimal test case?", "I think it might be a race condition between X and Y", "The logs show the error occurred at 14:32 UTC — let me check what was deployed around that time", "I'll add some logging to track the value through the pipeline."

Terminology nuances: Bug (informal, most common): unexpected incorrect behaviour. Defect (formal/QA): deviation from specification. Error: can mean a mistake in code OR a runtime error (exception thrown). Issue: broad term covering bugs, feature requests, and tasks in GitHub Issues / Jira. Incident: production problem affecting users. Anomaly: unexpected behaviour that may or may not be a bug. Context determines the right term.

Professional bug escalation: "I've been investigating this for two hours and I'm stuck — can I get a second pair of eyes?", "I've reproduced it consistently with this test case — the stack trace points to [X] but I'm not sure why", "I suspect it's related to [recent change] but I'm not certain", "I've ruled out [Y] and [Z] — I think it's in [component]." Show your work — explain what you've tried before asking for help. Senior developers appreciate structured problem presentation.

Bug classification vocabulary: off-by-one error (index is one too high or low), memory leak (memory not released after use), deadlock (two processes waiting for each other), race condition (result depends on timing), buffer overflow (writing past memory boundary), integer overflow (number exceeds type limit), null/undefined reference (accessing absent value), infinite loop (loop that never exits), floating point error (decimal arithmetic imprecision).

Intermittent bug language: "This happens roughly 1 in 10 times — I can't reproduce it on demand", "It seems to be timing-dependent — possibly a race condition", "We only see it under high load (>500 concurrent users)", "It started appearing after the last deployment but we can't reproduce it in staging", "The error is non-deterministic — the same input sometimes succeeds and sometimes fails". Include what you know about frequency and conditions — even partial information helps.

Root cause analysis (RCA) vocabulary: "The proximate cause was X, but the root cause is Y", "We're treating the symptom, not the disease", "The 5 Whys technique: why did X happen? → because of Y → why Y? → because of Z...", "The contributing factors were...", "The systemic issue is that our deployment process doesn't check for [X]". In post-mortems: distinguish trigger (immediate cause) from root cause (underlying system weakness).

Code archaeology phrases: "Let me git blame this line to see when it was changed", "The commit that introduced this regression was [hash]", "Looking at the git history, this was last touched 18 months ago", "The original author's commit message says [X] — so this was intentional", "There's no ticket reference in the commit — we don't know the context", "Let me look at the PR where this was introduced for context". Understanding git history is a debugging superpower.

Bug fix commit format: "fix(scope): description" — e.g., "fix(auth): handle expired JWT token gracefully", "fix(api): prevent null pointer when user profile is incomplete". In the body: explain what the bug was, what caused it, and how the fix resolves it. Include the ticket reference: "Fixes #1234". A good fix commit lets future developers understand WHY the code looks the way it does without having to reverse-engineer the bug.