Core jargon for software architecture, delivery, and engineering culture.
Standard, repetitive code that must be written in nearly the same form every time, carrying little logic of its own.
A structured process where one or more teammates read proposed changes before they merge, checking for bugs, design problems, and maintainability issues.
A surface-level pattern in code — not a bug by itself — that often signals a deeper design problem worth investigating.
A numeric score counting every possible route through a function — each branch or loop adds one. The higher the score, the more paths there are to test and reason about.
Code that exists in the codebase but can never be reached or executed under any condition.
"Don't Repeat Yourself" — any piece of knowledge or logic should exist in exactly one place in a system.
The same logic expressed in multiple places in the codebase, so a single change has to be made — and remembered — in every copy.
"Keep It Simple, Stupid" — favor the simplest solution that works over a more complex or clever one.
An abstraction meant to hide complexity that occasionally forces the caller to understand what's happening underneath anyway.
A static analysis tool that scans source code for style violations, suspicious patterns, and common bugs — without running it.
A literal value embedded directly in code with no explanation of what it represents, instead of being assigned to a named constant.
Restructuring existing code to improve its internal design and readability while deliberately keeping its external behavior unchanged.
The future rework cost you take on by choosing a quick solution now instead of a more thorough one.
A language feature or tool that assigns types to values and catches type mismatches before runtime — either at compile time (TypeScript, Java) or by inference.
"You Aren't Gonna Need It" — don't build functionality before it's actually needed, on the guess that it might be useful someday.