Flight Recorder Basics

The Mission Log Concept

Every spacecraft has a flight recorder—a black box that meticulously logs every system status, every decision, every event. If something goes wrong, investigators can replay the entire mission to understand what happened. Version control is your code's flight recorder.

What Is Version Control?

Version control is a system that records changes to files over time. It allows you to:

• Recall specific versions of files from the past
• See who modified something and when
• Compare changes between different time points
• Revert entire projects or individual files to previous states
• Work on different features simultaneously

Life Without Version Control

Imagine building a spacecraft without any way to track changes. You might:

• Save files like navigation_v1.py, navigation_v2.py, navigation_final.py, navigation_final_ACTUAL.py
• Have no idea what changed between versions
• Accidentally overwrite someone else's work
• Lose track of which version is stable
• Be unable to work on multiple features without creating chaos

This approach might work for solo missions with simple systems, but it falls apart quickly as complexity grows.

The Evolution of Version Control

First Generation: Local Systems

Early version control systems kept all versions in a local database on your computer. Think of it as a personal mission log. Simple, but you couldn't collaborate with other astronauts.

Second Generation: Centralized Systems

Systems like CVS and Subversion introduced a central server—like a main mission control database. All astronauts connected to this central hub to check out files and commit changes.

Advantages:

• Everyone could collaborate
• Administrators could control who accessed what
• One central source of truth

Disadvantages:

• If mission control went down, nobody could work
• Without network access, you couldn't commit changes
• If the central server's hard drive failed without backups, you lost everything

Third Generation: Distributed Systems

Git and similar systems are distributed. Every astronaut has a complete copy of the entire mission history—not just the current state, but every commit, every branch, every version ever created.

Think of it this way: Instead of only mission control having the master logs, every spacecraft has a complete, identical copy. If Earth's mission control is destroyed, any spacecraft can become the new central hub.

Key Version Control Concepts

Repositories

A repository (or "repo") is your mission database—the directory where Git stores all versions of your project. It contains:

• All your files
• Complete history of all changes
• Information about branches
• Metadata about commits

Commits

A commit is a snapshot of your project at a specific point in time. It's like a photograph of your spacecraft's systems at a particular moment. Each commit includes:

• A unique identifier (like a mission timestamp)
• The author's name and email
• A timestamp
• A message describing what changed
• A reference to the parent commit(s)

Branches

A branch is a parallel timeline. Imagine you want to test a radical new propulsion system without affecting your main spacecraft. You create a branch—an alternate reality where you can experiment freely. If it works, you merge it back. If not, you abandon that timeline.

Merging

Merging is combining changes from different branches. When two crews work on different systems simultaneously, merging brings their work together into a single unified timeline.

Why Version Control Matters for Teams

Consider a mission with five astronauts working on different spacecraft systems:

• Alice is upgrading the navigation system
• Bob is fixing the communication array
• Carol is optimizing the life support
• David is improving the propulsion
• Eve is updating the sensor array

Without version control, they'd constantly overwrite each other's work. With Git, each works on their own branch, and changes are merged systematically.

The Accountability Factor

Version control creates accountability. Every change is attributed to a specific person at a specific time with a specific reason (the commit message). If a bug appears, you can:

• See exactly when it was introduced
• See who introduced it
• See what the change was meant to accomplish
• Contact the author for clarification

This isn't about blame—it's about understanding. Like reviewing mission logs after an incident, it helps teams learn and improve.

Time Travel Capabilities

One of version control's superpowers is time travel. You can:

• Jump back to any previous version
• Compare code from different time periods
• Create new branches from old commits
• Cherry-pick specific changes from one timeline to another

Backup and Disaster Recovery

Because Git is distributed, every clone is a full backup. If your computer explodes (hopefully not while you're using it), you can clone the repository from GitHub or from any teammate's computer. Nothing is lost.

The Collaboration Multiplier

Modern software development is collaborative. Open-source projects have thousands of contributors. Version control makes this possible by:

• Allowing multiple people to work simultaneously
• Providing mechanisms to review changes before accepting them
• Maintaining a clear history of who did what
• Enabling code review and discussion

Preparing for Your First Commands

Now that you understand why version control exists and what problems it solves, you're ready to start using it. In the next phases, we'll install Git, configure it, and start making commits.