Clear definitions of software development terminology without the fluff.
snippet — A small, reusable piece of code extracted from a larger codebase. Example: for (auto& item : vec) process(item); as a range-based loop snippet.
polyfill — JavaScript code that implements missing browser APIs by patching native prototypes, enabling older browsers to support modern features. Example: if (!String.prototype.trim) { String.prototype.trim = function() {...} }.
shim — Library code that provides a compatibility layer with its own API, fixing functionality differences across platforms. Example: A shim might expose mylib.trim(str) instead of modifying String.prototype.
ponyfill — Similar to polyfill but exports standalone functions instead of patching native APIs, avoiding feature detection conflicts. Example: import trim from 'ponyfill-trim'; trim(text) instead of text.trim().
boilerplate — Repetitive code that must be written frequently with minimal variation. Example: CMake project setup with cmake_minimum_required(), project(), add_executable() in every new project.
stub — Minimal implementation that returns hardcoded values, used as placeholder during development. Example: int get_user_count() { return 0; } before database integration.
mock — Test double that simulates object behavior with expectations and verifications. Example: EXPECT_CALL(mock_db, query(_)).WillOnce(Return(result)); in GoogleMock.
scaffold — Auto-generated project structure with directories, config files, and basic code templates. Example: cmake --init creating initial project layout.
distro — Distribution package containing software with specific configurations, dependencies, and tooling. Example: Fedora KDE as your Linux distro.
vim distro — Pre-configured Vim/Neovim setup bundling plugins and settings. Example: LazyNvim with LSP, treesitter, and keybindings pre-configured.
transpiler — Tool converting source code from one language to another at similar abstraction levels. Example: TypeScript compiler producing JavaScript output.
bundle — Single file combining multiple modules/assets for deployment. Example: webpack merging app.js, utils.js, styles.css into bundle.js.
minify — Compression process removing whitespace, comments, and shortening identifiers to reduce file size. Example: function calculateSum(a,b){return a+b} from readable source.
legacy — Old codebase or system still in production but built with outdated technologies. Example: C++98 project without RAII or smart pointers.
greenfield — New project starting from scratch without existing constraints. Example: Designing new game engine architecture with modern C++20 features.
brownfield — Project involving modifications to existing codebase with established patterns and technical debt. Example: Adding Tracy profiler integration to legacy Garry's Mod addon.
monolith — Single unified application where all components run in one process. Example: Game server handling physics, networking, and rendering in single executable.
microservice — Architecture splitting functionality into independent deployable services communicating via APIs. Example: Separate services for auth, matchmaking, and game logic.
API — Application Programming Interface defining how software components interact. Example: void process_input(const char* data, size_t len); as public function signature.
SDK — Software Development Kit providing libraries, tools, and documentation for platform development. Example: Firebase SDK with headers, libraries, and symbol uploading tools.
middleware — Software layer sitting between systems to facilitate communication or add functionality. Example: Express.js routing requests between client and database.
FFI — Foreign Function Interface enabling code written in one language to call functions in another. Example: Python ctypes calling into C++ shared library.
ABI — Application Binary Interface specifying low-level calling conventions, data layout, and symbol naming. Example: Itanium C++ ABI defining vtable layout and name mangling.
release — Creating versioned build for distribution with specific feature set and quality bar. Example: Tagging v2.1.0 in git with compiled binaries and release notes.
deploy — Moving code from development/staging to production environment where users access it. Example: Uploading updated game server binary to hosting infrastructure.
rollback — Reverting to previous version after problematic deployment. Example: Switching back to v2.0.9 after v2.1.0 causes crashes.
hotfix — Urgent patch deployed directly to production bypassing normal release cycle. Example: Emergency fix for critical memory leak in production server.
backlog — Prioritized list of work items not yet started. Example: GitHub issues labeled "backlog" for future Garry's Mod addon features.
task — Specific unit of work assigned to developer. Example: "Implement Tracy profiler zones in physics system".
roadmap — Strategic plan outlining major features and timeline. Example: Q1 performance optimization, Q2 multiplayer features, Q3 modding API.
bug — Defect causing incorrect or unexpected behavior. Example: Crash when loading specific map due to null pointer dereference.
feature — New functionality added to codebase. Example: Adding weapon skin preview system to game client.
refactor — Restructuring code without changing external behavior to improve maintainability. Example: Extracting monolithic update() function into separate systems.
tech debt — Suboptimal design decisions or shortcuts requiring future rework. Example: Using raw pointers instead of RAII wrappers, requiring manual cleanup.
regression — Previously working functionality broken by recent changes. Example: Map loading fails after ECS refactor that worked before.
smoke test — Basic tests verifying critical functionality works after deployment. Example: Launch server, connect client, load map, verify no crashes.
sanity check — Quick validation that system behaves reasonably before deeper testing. Example: Assert config file exists before parsing.
flaky test — Test producing inconsistent results despite identical code. Example: Threading test occasionally failing due to race conditions.
fuzzing — Automated testing with randomized inputs to discover crashes and edge cases. Example: Feeding random byte sequences to packet parser looking for buffer overflows.
Heisenbug — Bug that disappears or changes when debugging is attempted. Example: Race condition that vanishes when running under debugger due to timing changes.
dev — Development environment for active coding and testing. Example: Local Fedora machine with debug builds and verbose logging.
stage — Staging environment mirroring production for final validation. Example: Test server with production-like config before release.
prod — Production environment serving real users. Example: Live game servers running release builds with crash reporting.
CI — Continuous Integration automatically building and testing code on every commit. Example: GitHub Actions compiling project and running test suite on push.
CD — Continuous Deployment/Delivery automating release pipeline to production. Example: Automatic deployment to servers after passing CI checks.
container — Isolated runtime environment packaging application with dependencies. Example: Docker container with game server, libraries, and config files.
Docker image — Template containing filesystem layers and metadata for creating containers. Example: Base image with LLVM toolchain for building C++ projects.
orchestrator — System managing deployment, scaling, and lifecycle of containers. Example: Kubernetes scheduling game server pods across cluster nodes.
Kubernetes — Container orchestration platform automating deployment, scaling, and management. Example: K8s cluster auto-scaling server instances based on player count.
infrastructure as code — Managing infrastructure through version-controlled configuration files. Example: Terraform scripts defining server resources and networking.
junior — Entry-level developer learning fundamentals and working on defined tasks with supervision. Example: Implementing UI elements based on detailed specifications.
middle — Intermediate developer handling features independently with solid technical skills. Example: Designing and implementing entire weapon system module.
senior — Experienced developer making architectural decisions and mentoring others. Example: Designing ECS architecture and reviewing team's code.
team lead — Developer managing team coordination, priorities, and technical direction. Example: Planning sprint, resolving blockers, conducting 1-on-1s.
architect — Technical leader defining system design, standards, and long-term technical strategy. Example: Choosing build system, establishing C++ coding standards, designing service boundaries.
yak shaving — Chain of nested prerequisite tasks increasingly distant from original goal. Example: Fixing bug → upgrading compiler → resolving dependencies → debugging build system.
bikeshedding — Spending disproportionate time debating trivial decisions while avoiding complex ones. Example: Team arguing about variable naming convention instead of addressing architecture flaws.
cargo cult — Copying practices or technologies without understanding their purpose or applicability. Example: Using microservices because "Google does it" for simple project.
dogfooding — Using your own product internally to validate quality and identify issues. Example: Playing your game builds before release to experience player perspective.
bus factor — Number of team members who could be hit by bus before project becomes unmaintainable. Example: Single developer knowing entire legacy codebase creates bus factor of 1.
idempotency — Property where operation produces same result regardless of how many times it's executed. Example: SET value = 5 is idempotent, INCREMENT value is not.
thunk — Delayed computation wrapped in function for lazy evaluation or callback. Example: auto thunk = [=]() { return expensive_calculation(); }; thunk();.
trampoline — Loop repeatedly calling functions that return next function to call, avoiding stack overflow in recursion. Example: Converting recursive parser to iterative trampoline for deep nesting.
dead code elimination — Compiler optimization removing unreachable or unused code from final binary. Example: LLVM removing unused functions when building with -O2.
monkey patching — Runtime modification of code behavior by replacing methods or functions. Example: Hooking WinAPI functions with LD_PRELOAD for memory tracking.
RAII — Resource Acquisition Is Initialization pattern where resource lifetime is tied to object scope. Example: std::unique_ptr<T> automatically freeing memory when going out of scope.
OOM killer — Linux kernel mechanism terminating processes when system runs out of memory. Example: Game server killed by OOM when allocating excessive memory.
context switch — OS operation saving current thread state and loading another, incurring performance cost. Example: Frequent thread switching degrading cache efficiency.
cache miss — CPU accessing data not present in cache, requiring slower RAM fetch. Example: Random memory access pattern causing L1/L2 cache misses.
branch prediction — CPU guessing conditional jump outcomes to maintain instruction pipeline. Example: Mispredicted branches in hot loop causing pipeline stalls.
vtable dispatch — Runtime method lookup through virtual function table pointer. Example: virtual void update() requiring pointer dereference for each call.
undefined behavior — Code violating C++ language rules with unpredictable results, allowing aggressive compiler optimizations. Example: Dereferencing null pointer enabling compiler to assume pointer is never null.
feat — Commit introducing new feature for end users, correlating with MINOR version in semantic versioning. Example: feat: add weapon skin preview system.
fix — Commit patching bug in codebase, correlating with PATCH version in semantic versioning. Example: fix: prevent crash when loading corrupted map files.
docs — Documentation-only changes without code modifications. Example: docs: update CMakeLists.txt build instructions.
style — Formatting changes like whitespace, semicolons, or indentation with no functional impact. Example: style: format physics.cpp with clang-format.
refactor — Code restructuring that neither fixes bugs nor adds features. Example: refactor: extract entity spawning logic into separate system.
test — Adding new tests or modifying existing test code without production changes. Example: test: add unit tests for collision detection edge cases.
chore — Routine maintenance tasks like updating dependencies, build configs, or tooling. Example: chore: bump Tracy profiler to v0.10.
build — Changes affecting build system or external dependencies like CMake, npm, or package managers. Example: build: migrate to C++20 modules in CMakeLists.txt.
ci — Changes to continuous integration configuration files or scripts. Example: ci: add clang-tidy checks to GitHub Actions workflow.
perf — Code change improving performance without altering functionality. Example: perf: optimize collision checks using spatial partitioning.
revert — Commit undoing previous commit. Example: revert: "feat: add experimental multiplayer mode".
BREAKING CHANGE — Footer indicating incompatible API changes, correlating with MAJOR version bump. Example: feat: redesign config API\n\nBREAKING CHANGE: Config::load() now returns Result<T> instead of throwing.
scope — Optional component/module identifier in parentheses after type. Example: fix(renderer): correct texture filtering for high-DPI displays.