Student Glossary
English is a funny thing, and most words have multiple meanings and uses, and they’re constantly change.
The following glossary is meant to explain a number of terms as I use them in my coaching, speaking, courses, and other content, and may not necessarily represent the global definition of these terms in the strictest sense.
Note: This document is never “complete,“ and may be updated or changed at any time, as I add new terms, or tweak my understanding/usage of various terms.
Continuous Delivery (CDE)
CDE (frequently called simply “CD”, and thus easily conflated with Continuous Deployment) is the practice of continuously and automatically delivering a software package so that it is ready to release on demand. This implies the use of Continuous Integration, so that as every change is merged to mainline, a completed software package is produced, and ready to be deployed.
Read more:Continuous Deployment (CD)
Continuous Deployment takes Continuous Delivery one step further, by not only building the complete software package automatically, but also deploying it to production servers. With CD, code changes are typically visible to end-users of the software within minutes.
Read more:Continuous Integration (CI)
Broadly speaking, CI is “the practice of merging all developers’ working copies to a shared mainline several times a day”. By extension a “CI Pipeline” (often shortened, simply to “CI”), is a set of scripts that execute various tests against every change, as it is made to the codebase, to prevent breaking changes from being merged into the mainline. This is typically where linters, unit tests, integration tests, and end-to-end tests are executed.
Read more:Test-Driven Development (TDD)
TDD or Test-Driven Development is a software development process in which code is written in a short repeating cycle of a few seconds or minutes at most:
- Write a failing test
- Write the minimum code to make the test pass
- Refactor to improve structure
Trunk-Based Development (TBD)
Trunk-Based Development (TBD) is a source-control branching model where developers collaborate on code in a single branch, often called trunk (or main or master in git), and avoid other long-lived development branches dictacted by some other brancing models, therefore avoid merge hell, do not break the build, and live happily ever after.