GitHub is a web-based platform where developers store, share, and collaborate on code. It is built around Git, a version control system that tracks changes to files over time, but GitHub adds hosting, a web interface, issue tracking, and social features like profiles and followers. In this course, GitHub is more than a storage location: it is the place your work lives, the record of your progress, and — through GitHub Pages — the server that will publish your websites to a public URL.
Before you can publish anything, you need an account. Choosing a username matters more than it might seem, because your GitHub Pages site addresses are derived from it and because your profile is often the first thing an employer or collaborator sees. Take a few minutes to pick something professional and readable, then fill in a profile photo, name, and bio so your account looks like it belongs to a real developer rather than an abandoned test account.
As you watch the videos below, look for three things: the distinction between Git (the tool) and GitHub (the service), the basic mechanics of creating a repository where files are stored, and the profile and security settings that make your account usable and safe. You do not need to master every feature shown — focus on the vocabulary and the steps you will repeat all semester.
This video explains the difference between Git, the distributed version control system that runs on your own machine, and GitHub, the hosted service built on top of it. Expect coverage of core concepts such as repositories, commits, branches, and how remote hosting enables collaboration and issue tracking. It frames the two tools as complementary rather than interchangeable.
It directly addresses the 'What is GitHub?' and 'Why GitHub is Used' subtopics, and clearing up the Git/GitHub confusion early prevents a very common beginner misunderstanding. IBM Technology produces concise, whiteboard-style explanations aimed at newcomers.
A beginner-oriented walkthrough, produced by GitHub itself, of creating your first repository through the web interface. It is likely to cover naming a repository, choosing public or private, adding a README, and understanding what the repository page shows you. This is the practical counterpart to the conceptual video above.
Coming from GitHub, the interface shown matches what you will actually see when you sign up, which makes it reliable for following along step by step. It bridges account creation and the repository work you will begin in this module.
A short tutorial on setting up and customizing your GitHub profile, including profile details and security settings. Expect guidance on presenting yourself professionally and on protecting the account, likely touching on topics such as two-factor authentication. The brevity makes it an easy final step after your account exists.
It maps directly onto the 'Configuring Your GitHub Profile' subtopic and adds account security, which matters because this account will host your published coursework all semester.
Together these videos cover the first half of MO1: understanding what GitHub is, creating an account, configuring a professional and secure profile, and creating the repository that will later hold your HTML files. The Git versus GitHub explanation also builds the vocabulary — repository, commit, push, remote — that you will need to execute the commit-push-verify workflow in MO3 and to describe the local-to-live pipeline in MO5. The repository tutorial in particular sets up the container that GitHub Pages will later build and serve, which is the foundation for MO4.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
A repository — usually shortened to "repo" — is the folder GitHub keeps for a single project. It holds your files, a full history of every change you save, and the settings that decide who can see the project. Before you can write a line of HTML for this course, you need a place to put it, and that place is a repository you create and configure yourself.
Creating a repo looks like a short form, but each field matters. You will navigate to the New Repository page, choose a name (which later becomes part of your public GitHub Pages URL), decide between public and private visibility, and choose whether to initialize the repo with a README file. After you click Create, you should be able to recognize that the repository exists, read its landing page, and find the controls for adding files.
While watching these videos, pay attention to where the "New" button lives, how the name field reacts as you type, what the public/private choice actually changes, and what the repository page looks like immediately after creation. Also notice the different ways files get into a repo — drag-and-drop upload, the web editor, and the commit-based GitHub flow — because you will use those methods throughout the module.
An official GitHub beginner tutorial that walks through creating a repository from start to finish. Based on its title and description, it covers getting to the new repository screen, filling in the name and description, choosing visibility, and the initialization options such as adding a README. It ends with the newly created repository so you can see what success looks like.
This is produced by GitHub itself, so the interface and terminology match what you will see in your own account, and it maps directly onto every subtopic from navigating to the New Repository page through confirming creation.
A short, focused video showing how to get existing files and folders into a GitHub repository. It demonstrates more than one approach to uploading, so you can see both the browser-based upload path and an alternative method for moving a project into your repo.
Creating an empty repository is only useful once something is in it; this GitHub-produced clip is the natural next step and reinforces what the repository landing page offers right after creation.
This tutorial introduces the GitHub flow and how code is actually added to a repository within it. Expect coverage of working with files, making changes, and saving them back to the repo through commits, framed as a repeatable process rather than a one-time upload.
It connects the setup steps you just completed to the ongoing workflow you will use all semester, and it comes from GitHub's own beginner tutorial series, so the vocabulary is consistent with the previous videos.
These three videos build the first half of MO1: an official, step-by-step walkthrough of creating and configuring a repository, which is the container your GitHub Pages site will later be published from. Because the repository name becomes part of your public site URL, the naming and visibility segments also prepare you for MO4, where you explain how GitHub Pages derives a URL from your username and repository name. The upload and GitHub flow videos introduce the commit-based habit behind MO3 and MO5, showing how files move from your machine into a repository on GitHub before anything can appear on a live site. The HTML structure work in MO2 happens in a later topic, but you will need this repository ready to hold that first index.html file.
These videos were chosen from YouTube on October 3, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
GitHub Pages is a free static site hosting service built into GitHub. Once you turn it on for a repository, GitHub takes the files you have committed — HTML, CSS, images — and serves them at a public web address that anyone can visit. There is no server to rent, no FTP client to configure, and no build server to maintain: publishing is simply a matter of pushing your work to the right branch and folder.
This matters in COP4813 because GitHub Pages is the delivery end of the workflow you will repeat all semester. You will edit files locally, commit and push them to GitHub, and then confirm the change appears on your live site. Understanding that the URL is derived from your username and repository name, and that GitHub rebuilds automatically after each push, removes most of the mystery when something does not appear as expected.
As you watch the videos below, pay close attention to three things: where the Pages settings live in the repository (Settings, then the Pages section), which branch and folder are selected as the publishing source, and the exact shape of the resulting URL. Also notice that publication is not instant — there is a short build delay, so a page that looks missing may simply need a refresh a minute later. Interfaces change over time, so expect small differences between what you see on screen and GitHub's current layout; the underlying steps remain the same.
A step-by-step walkthrough of hosting a website on GitHub Pages, from repository setup through to a live, publicly reachable site. At roughly fifteen minutes, it has room to explain the reasoning behind each step rather than just clicking through, and to show the published result in a browser.
The longer format makes it the best choice for students who want the full picture of what GitHub Pages is and how the publishing process works, covering enabling Pages, the resulting URL, and verification in one continuous demonstration.
A fast, focused tutorial that builds a simple portfolio site and publishes it with GitHub Pages in about five minutes. It emphasizes the practical path from an empty repository to a shareable public link you can show employers or clients.
With over 170,000 views, this is a widely used quick reference that cleanly demonstrates enabling Pages and obtaining a live URL — useful as a concise review after the longer walkthrough, and a reminder of why a public link is worth having.
A short, recent guide to hosting a website on GitHub for free using GitHub Pages, showing the key clicks needed to turn a repository into a published site. Its brevity means it concentrates on the essential settings and the resulting address.
Being the most recent of the three, it is likely to reflect a GitHub interface closest to what you will see today, making it a helpful cross-check if the menus in the other videos look unfamiliar.
Together these videos support MO1 by demonstrating the full configuration path from repository to enabled GitHub Pages deployment, and MO3 by showing the push-then-verify habit of checking the live site in a browser after publishing. They reinforce MO4 by making visible how GitHub detects committed changes, rebuilds, and serves the result at a username-and-repository-based URL, and they illustrate MO5 by placing local files, the GitHub repository, and the published site side by side as three distinct stages of one pipeline. While they do not teach HTML structure directly (MO2), they give you the hosting destination where the minimal HTML document you build in this module will be published and verified.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Every web page you will build in this course begins as a plain text file with a predictable skeleton. HTML (HyperText Markup Language) is not a programming language; it is a markup language that uses tags to label the parts of a document so a browser knows what each piece of content is. In this topic you will write your first complete HTML file and display the words "Hello, World" in a browser.
The structure you learn here is small but non-negotiable. The DOCTYPE declaration tells the browser to use modern standards mode, the root html element wraps everything, the head element holds information about the page (such as the title shown on the browser tab and the character encoding), and the body element holds everything a visitor actually sees. Getting this minimal structure right matters immediately, because the file you create here is the same file you will commit, push, and publish to GitHub Pages later in the module.
As you watch, focus on three things: the exact order and nesting of the doctype, html, head, and body; which content belongs in the head versus the body; and how opening and closing tags pair up to form elements. Try to pause each video and retype the structure yourself from memory rather than copying it — the goal is to be able to produce a valid blank page without looking anything up.
A brief, beginner-oriented introduction to what HTML is and what an HTML document looks like, from the W3Schools video series. In roughly three minutes it is likely to walk through a simple example page and name the parts of the basic document structure, including the doctype, html, head, title, and body.
W3Schools is a long-standing, widely used reference for web standards, and its short format gives you an accurate first look at the document skeleton before you write your own file.
A fast-paced tour of HTML fundamentals with timestamps for setting up a project, tag syntax, headings, attributes, and the basic HTML structure. The chapter on the basic HTML structure directly covers assembling the doctype, html, head, and body into a working page.
The chapter markers let you jump straight to the structure section that matches this topic, and seeing a page built from an empty file to a rendered result reinforces how the pieces fit together.
A more deliberate, explanatory treatment of HTML as the standard language for creating and organizing page content. At thirteen minutes it has room to explain not just what each element is but why it exists and how the browser interprets the markup.
The slower, instructor-style pacing suits students who want the reasoning behind the structure rather than just the syntax, making it a good follow-up or review after the shorter videos.
These three videos together support MO2 by showing the same minimal document structure — DOCTYPE, root html element, head, and body — from three perspectives: a quick standards-reference overview, a hands-on build, and a slower conceptual explanation. Because the "Hello, World" file you produce from these videos becomes the file you commit and publish, they also set up MO1, MO3, MO4, and MO5 by giving you valid content to push to your repository and verify at your live GitHub Pages URL.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Writing an HTML file on your own computer is only half the job. Until that file is staged, committed, and pushed to GitHub, it exists nowhere but your laptop. This topic walks through the final steps of the local-to-live pipeline: selecting the changes you want to record (staging), saving them as a labeled snapshot with a message (committing), sending that snapshot to your remote repository on GitHub (pushing), and then confirming the result by visiting your GitHub Pages URL in a browser.
Two details trip up most beginners. First, GitHub Pages does not publish instantly — after a push, GitHub runs a short build and deploy process, so a page may take a minute or two to appear or update. Second, your Pages URL is predictable: it is derived from your GitHub username and repository name, so you should know exactly where to look rather than hunting for a link. If the page shows a 404 or stale content, the usual causes are an unpushed commit, a file named something other than index.html, or simply checking too soon.
As you watch these videos, focus on the mechanics rather than memorizing commands. Notice the difference between a file that is modified, staged, and committed; watch where the push button or command appears; and pay attention to how the interface signals that your local branch is ahead of or in sync with the remote. The commit-push-verify loop you see here is the same cycle you will repeat for every assignment in this course.
An official GitHub walkthrough of the core Git commands a beginner needs, starting with initial configuration and moving through the everyday commands with worked examples. Based on its title and description, it should cover commands such as git add, git commit, git status, and git push — the exact sequence behind staging, committing, and sending work to GitHub. The examples format means you see each command typed and its effect explained rather than just a list of definitions.
It comes directly from GitHub, so the terminology and workflow match the platform you are publishing to, and it gives you the command-line foundation for the staging, committing, and pushing subtopics even if you normally use a graphical interface.
The official Visual Studio Code team's compact introduction to using Git and GitHub from inside the editor, with chapter markers for initializing a repository, renaming a branch, and related steps. It demonstrates the Source Control panel, where modified files appear and where you stage changes, type a commit message, and publish or push to GitHub. At under seven minutes it is a fast orientation to the buttons and panels you will use repeatedly.
Because most students in this course will commit and push from VS Code rather than a terminal, this video shows the exact interface for the staging and pushing subtopics, and it comes from the editor's own team so the UI walkthrough is authoritative.
A recent GitHub tutorial on managing version control inside VS Code without switching between tools. It covers connecting the editor to GitHub and handling the routine commit and push cycle from a single window, reflecting the current version of the interface. Being only a few months old, it is the closest match to the menus and buttons you will see today.
Its recency makes it a reliable visual reference when older videos show outdated menus, and its focus on the uninterrupted commit-push loop reinforces the recurring workflow at the center of this topic.
These videos target the publishing half of the module. Together they give you both the command-line and the VS Code versions of staging, committing, and pushing, which is the core mechanical skill behind MO3's commit-push-verify workflow and the middle stage of the pipeline described in MO5. Seeing your commit arrive in the remote repository on GitHub connects directly to MO1's hosted deployment and sets up MO4, where you then wait briefly for the automatic rebuild and load your username-and-repository-based Pages URL to confirm the HTML file you built for MO2 renders as expected. The videos cover the Git side; the course materials supply the GitHub Pages build delay, URL pattern, and verification steps that complete the loop.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Every change you make in this course travels the same path: you edit a file on your own computer, you record and send that change to GitHub, and then the live site served by GitHub Pages reflects what you sent. Those three stages — local editing, committing and pushing, and live publication — form the local-to-live pipeline. Learning to see them as distinct steps makes it much easier to diagnose problems later: a file saved but not committed, a commit made but not pushed, and a push that hasn't finished rebuilding the site all look different once you know what to check.
This workflow matters here because it is the pattern you will repeat for the rest of the term. Rather than uploading files by hand, you will keep a local copy of your project, use Git to track changes, and let GitHub Pages serve the result at a public URL. The same habits also transfer directly to professional web development, where version control is the normal way teams edit, review, and deploy code.
As you watch the videos below, focus on three things: what a commit actually is (a recorded snapshot, not a save), the difference between committing locally and pushing to a remote repository on GitHub, and where each step happens — in your editor, in your local repository, or on GitHub's servers. Don't worry about memorizing commands on the first pass; aim to build a mental map of the pipeline so the hands-on steps later in the module feel like confirmation rather than guesswork.
A short, animated overview of how Git works under the hood, from ByteByteGo. Based on its title and description, it should explain the core Git concepts behind the workflow — the working directory, staging, commits as snapshots, and how a local repository relates to a remote one such as GitHub.
At roughly four minutes it gives you the conceptual model first, which is exactly what you need to distinguish the three stages of the local-to-live pipeline before you start typing commands.
The official Visual Studio Code beginner tutorial for using Git inside the editor. Its chapter list indicates it walks through initializing a repository, renaming a branch, and working with Git through VS Code's interface, so you should see the edit-then-commit cycle demonstrated in the same kind of editor you will likely use.
It comes straight from the VS Code team and shows the local editing and committing stages in a graphical workflow, which is the most common way students will actually perform these steps.
A beginner-oriented tour of essential Git commands, produced by GitHub. Based on the title and description, it starts with configuring Git and then works through the commands you use repeatedly, which typically include staging changes, committing them, and pushing to a remote repository.
Coming from GitHub itself, it is an authoritative reference for the commit and push portion of the pipeline, and it is the video to return to when you need the exact command for a step.
Together these videos build the conceptual and practical foundation for the module's workflow outcomes. The ByteByteGo explainer supports MO5 by making the stages of the local-to-live pipeline distinguishable, and it indirectly supports MO4 by clarifying what a push actually sends to GitHub so you can reason about when Pages rebuilds. The VS Code tutorial and GitHub's command walkthrough support MO3 by demonstrating the commit and push steps you will execute to publish an HTML file, and they reinforce the repository habits behind MO1. None of the videos teach HTML structure (MO2) or GitHub Pages setup directly — those come from the module's other materials and your hands-on work — but the workflow shown here is the vehicle you will use to get that HTML file onto your live site and verify it there.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.