Computing

/käm-pə-ˈlā-shən/

noun — "turning readable instructions into something a machine can run."

Compilation is the process of translating source code written in a high-level programming language into a lower-level form that a computer can execute, typically machine code or bytecode. This transformation is performed by a program called a compiler.

In essence, compilation is a conversion step: it takes human-readable instructions and produces a form optimized for execution by hardware or a runtime system.

/sȯrs kōd/

noun — "the readable form of instructions a system turns into action."

Source Code is the human-readable set of instructions written by programmers that defines how a program behaves. It is the original form of software before it is transformed into machine-executable form by compilers, interpreters, or other processing tools.

Source code is written in programming languages such as C, Python, JavaScript, or many others. These languages exist to express logic in a way humans can understand while still being precise enough for machines to execute.

/ˈvɝː-ʒən kən-ˈtrōl/

noun — "memory for systems that refuse to stay still."

Version Control is a system for tracking, managing, and organizing changes to files over time, most commonly used in software development. It allows developers to record snapshots of a project, compare differences between versions, revert to earlier states, and coordinate changes made by multiple people without overwriting each other’s work.

/ˈō-pən sȯrs ˈsȯft-ˌwer/

noun — "software whose source code is available to inspect, modify, and share."

Open Source Software is software distributed under a license that allows users to view, study, modify, and redistribute its source code. Unlike proprietary software, where the underlying implementation is typically hidden and controlled by a single vendor, open source software exposes the code itself, enabling anyone to understand how it works and, within the terms of its license, build upon it.

/fȯrk/

noun, verb — "one thing becoming two."

Fork is the act or result of creating an independent copy of an existing project, codebase, process, or development path. After a fork occurs, the original and the new version continue separately, potentially evolving in different directions over time.

/ˌriː-ˈfæk-tər-iŋ/

noun — "changing the structure without changing the behavior."

Refactoring is the disciplined process of restructuring existing code, systems, or designs without altering their external behavior. The goal is not to add new features or fix bugs directly, but to improve internal clarity, reduce complexity, and make future changes easier and safer.

/ˈtek-nɪ-kəl det/

noun — "the interest you pay on shortcuts you didn’t mean to take."

Technical Debt is the accumulation of future cost created when software is built in a way that is expedient today but suboptimal for long-term maintenance, scalability, or clarity. It is not necessarily a mistake in the moment of creation; rather, it is a trade-off where speed of delivery is chosen over structural purity, with the understanding that the “borrowed time” will eventually need to be repaid.

/ˌsa-nə-tə-ˈzā-shən/

noun — "making input safe without necessarily changing what it means."

Sanitization is the process of modifying, filtering, escaping, encoding, or transforming data so that it can be safely processed, stored, displayed, or transmitted by a system. Unlike Input Validation, which determines whether data is acceptable, sanitization focuses on making accepted data safe to use within a particular context.

/ˈin-pu̇t va-lə-ˈdā-shən/

noun — "trust nothing, verify everything."

Input Validation is the process of examining, filtering, and verifying data before it is accepted, processed, stored, or acted upon by a system. Its purpose is to ensure that incoming data conforms to expected rules, formats, ranges, and constraints, preventing errors, security vulnerabilities, and unexpected behavior.

/ej kās/

noun — "the weird input nobody expected until it broke everything."

An Edge Case is an unusual, extreme, rare, or unexpected condition that occurs at the outer limits of a system's intended operation. While most software is designed around common inputs and predictable workflows, edge cases live at the fringes where assumptions begin to fail and hidden weaknesses become visible.