Skip to content

Welcome to the Git & GitHub Guide

◼ Beginner
◆ Intermediate
❈ Collaboration

This guide was developed to establish a clear, structured, and scalable understanding of Git and GitHub — for students at all levels, and for any developer who wants to build or rebuild their understanding on solid foundations.

It is written with intentional depth.

It does not remove complexity. It explains it.

There is an important difference between those two approaches. Many guides reduce Git to a sequence of steps: run this command, then this one, then push. That works until something goes wrong — and something always goes wrong. When it does, the developer who was given steps has nothing to fall back on. The developer who was given understanding can reason through the problem.

This guide aims to produce the second kind of developer.

I. Who This Guide Is For

This guide is written for:

  • Students encountering Git for the first time, who need a clear mental model before touching any commands
  • Students working on collaborative projects, who need to understand branching, pull requests, and shared workflow
  • Senior students preparing for industry, who need to develop the discipline and depth that professional environments expect
  • Lecturers aligning workflow and assessment, who need a reference that connects academic practice to professional standards
  • Any developer — at any stage — who wants structured Git literacy rather than scattered knowledge collected from tutorials and Stack Overflow

You do not need prior Git experience to begin.

You do need discipline to progress. Git is not difficult, but it requires consistency. The developers who struggle with Git are almost always the ones who skip steps, assume commands, or ignore the feedback that Git provides. This guide asks you to slow down, read carefully, and understand each stage before moving to the next.

II. How to Use This Guide

This guide supports two reading modes.

Follow the sections in order:

I. Foundations
II. Guided Practice
III. Professional Standards
IV. Collaboration
V. Advanced Topics

This sequence ensures proper conceptual layering. Each section builds on the understanding established by the previous one. Concepts introduced in Foundations are assumed in Guided Practice. Habits formed in Professional Standards are relied upon in Collaboration. Do not skip ahead — the order is intentional.

Reference Mode — For Experienced Users

If you already use Git regularly, you may navigate directly to the section most relevant to your current need:

  • Jump to Branching for collaborative workflow structure
  • Review Pull Requests for review and merge discipline
  • Study Recovery techniques for undoing mistakes safely
  • Consult Troubleshooting for specific error resolution

However, if confusion arises at any point — if a command behaves unexpectedly, if a workflow breaks down, if a concept does not quite make sense — return to Foundations.

Most Git problems are not technical. They are conceptual. The fix is almost never a new command. It is a clearer understanding of the model.

III. Concepts Before Tools

This guide consistently prioritises:

Understanding before interface.

The Git model — working directory, staging area, local repository, remote repository, branching, merging — is the same regardless of which tool you use to interact with it. Whether you use:

  • Command Line
  • Visual Studio Code
  • Visual Studio
  • Android Studio
  • NetBeans
  • GitHub Desktop

The underlying Git model does not change. The commands being executed do not change. What changes is only the surface through which you interact with them.

If you understand Git conceptually, any tool becomes manageable — because you know what the tool is doing beneath the buttons.

If you only understand a tool, Git remains confusing — because the moment the tool behaves differently, or the moment you need to switch tools, your understanding does not transfer.

This is why the guide begins with concepts. Not because commands are unimportant — they are essential — but because commands without understanding are fragile. They work until they do not, and then the developer is helpless.

IV. Expectations

By working through this guide, you are expected to develop the following:

  • A genuine understanding of what a repository is — not just how to create one, but what it contains and why
  • The ability to differentiate between local and remote, and to reason about the relationship between them
  • The judgment to know when to pull before pushing — and to understand what happens when you do not
  • The discipline to avoid destructive commands unless you fully understand their consequences
  • A structured commit history that reflects your actual development process
  • The ability to contribute responsibly in team environments, without breaking shared work

This guide does not aim to make Git "easy."

It aims to make Git clear.

Clarity reduces fear — because you are no longer guessing. Structure reduces mistakes — because disciplined habits prevent the situations that cause them. Understanding builds confidence — because when something unexpected happens, you have a model to reason from.

V. A Note on Discipline

Git rewards discipline — consistently, and in proportion to the effort invested.

Disciplined Git practice looks like this:

  • Small, focused commits that record one logical change at a time
  • Clear, specific commit messages that communicate intent to anyone reading the history
  • Logical branch structure that separates stable work from work in progress
  • Controlled merging that happens only when changes are ready and reviewed

Git also reveals the absence of discipline — equally consistently.

Shortcuts in Git look like this:

  • Force pushing, which overwrites remote history and can destroy other contributors' work
  • Massive commits that bundle hours of unrelated changes into a single, indescribable snapshot
  • Ignoring pull conflicts until they accumulate into something unresolvable
  • Copying folders instead of versioning — the modern equivalent of "Project_Final_Real_v2"

Your workflow reflects your mindset.

Develop it intentionally. The habits you build while learning Git are the ones you will carry into every professional environment you enter. They are worth building correctly.

Proceed to:

→ Installation & Configuration