Learn Git, GitHub and GitHub Actions

Begin using git by configuring settings and mastering basic commands. Felipe Gavilan introduces core concepts and hands-on steps to start working with git in this module.

Configure your git identity with global and local settings, setting your username and email. Learn to read global values, choose a code editor, and remove unused fields.

Explore repositories as the basic work unit in git, including local and remote setups, clone-push-pull workflow, and the three core parts: working directory, staging area, and git directory.

Initialize a local repository with git init in your project folder to create a dot git directory that stores branches and history, with master as the default branch.

examine the repo status with git status to see on master, learn what commits mean, and track changes by adding files with git add before committing.

Learn to use git add to move changes into the staging area, including untracked files, see what’s staged with git status, and selectively stage files or folders before committing.

Persist changes to the repository using git commit, write brief commit messages, and manage staging with git add and git status, including tracked vs untracked files, deletions, and multi-commit workflows.

Explore the basic git workflow, highlighting the working directory, staging area, and repository. Use git add to stage changes and git commit to persist them to the repository.

Explore how git log reveals commit history, showing commit ids, authors, dates, and messages, with options to view only recent commits or by file. Emphasize concise commit messages for clarity.

Learn how to amend commits with git commit --amend to modify commit messages and staged changes, including adjusting files in the staging area and validating changes with git log.

Verify commit contents with git show, inspecting sha, author, date, message, and changes; use head or head tilde to view latest or previous commits and see insertions and deletions.

Learn to undo unwanted changes in your working directory with git restore, restore specific files or all, and understand why restore replaces checkout.

See how git reset removes changes from the staging area after a mistaken git add, while git restore replaces working directory changes with the repository version.

Use git reset --soft to undo a commit by moving the head back while keeping changes in the staging area, allowing you to amend and recommit before sharing.

Learn how to revert a commit instead of rewriting history when a repository is shared. Create a new revert commit that undoes previous changes, then inspect via git log.

Learn to handle merge conflicts when reverting changes in git by choosing which lines to keep or combine, using Visual Studio Code.

Use git diff to see added, modified, and deleted lines in your files. Stage changes with git add, view staged diffs with git diff staged, and commit updates.

Learn to write commit messages that describe what the change does, avoid generic wording, keep messages brief, and include task IDs when linked.

Learn to write multi-line commit messages by omitting -m and editing in a text editor, then commit. Stage changes with git add and verify with git log.

Learn to override global credentials by setting a local username for a specific repository and verify changes with git log. Unset local credentials to revert to the global configuration.

Learn to use .gitignore to exclude secrets, compiled files, and folders like bin and node_modules, keeping your repository clean and noise-free.

Explore the core git workflow from working directory and staging area to repository, using init, status, commit, log, show, and restore, with concise commit messages and gitignore to exclude files.

Explore branches to isolate new work in a project, enabling effective and professional organization. Learn how branches support clean collaboration and workflow.

Explore git branches as independent versions of a project to safely develop features, then merge into the main or master branch after testing, avoiding edits on master.

Create a new branch to start from scratch, switch to the branch, and commit changes, showing how branches copy the project and keep master intact, then merge back into master.

Learn to merge the create new paragraph branch into the master branch with git merge, and understand fast-forward merges and merge conflicts in the new branch.

Merge when the original branch has new commits after creating a new branch, resolve potential conflicts, and complete a merge commit using git switch and git merge.

Practice merging across branches by resolving a merge conflict, using git merge and abort commands, and by hand edits in Visual Studio Code to combine changes from master and conflict.

Delete unused branches to prevent noise; use git branch -d to remove a branch and verify removal with git branch.

Use clear, short branch names that indicate work, group by purpose with prefixes like feature/ or bug fix, merge frequently, and delete finished branches.

Explore two key git workflows, GitHub flow and git flow, and learn how structured methodologies replace ad hoc work as you manage projects with git.

GitHub flow uses feature branches and pull requests to review and merge changes into main, enabling fast iterations and fewer conflicts.

Learn the Git flow workflow with main and develop branches, and feature, bug fix, hotfix, and release branches that organize development, testing, and versioned deployments.

Master branches by creating independent versions, listing, creating, switching, merging, and deleting branches, resolving merge conflicts, and comparing GitHub flow and git flow.

Explore advanced Git commands to maintain a clean commit history and learn how to save work that you are not ready to commit, equipping you for disciplined version control.

Using branches isolates work but can make commit history hard to follow. The lecture shows visualizing history with git log graph and introduces a technique to clean up the history.

Rebase reorganizes commits to create a linear history and rewrite history, then compare it to merge and perform a fast-forward merge to simplify the log graph.

balance commit frequency by squashing multiple commits into a single, clean history using interactive rebase, with practical steps from creating a branch to merging.

Save your in-progress changes with git stash to switch branches without losing work, since stash is local, then recover and apply later with stash list and stash pop.

Apply a specific commit from one branch to another using cherry-pick to fix errors across branches without a full merge.

Learn how to name commits with tags, create annotated tags like v1.0.0, view them with git log, delete tags, and use tags to mark software releases on GitHub.

Master rebase for a clean history, squash commits, stash work in progress, cherry-pick changes across branches, and use tags to name software versions.

Begin the second part of the course by exploring basic aspects of GitHub with Felipe Gavilan.

GitHub is a centralized platform that hosts repositories, history, branches, and tags, enabling collaboration with bug reports, documentation, and security rules; it offers public or private repositories and inviting collaborators.

Explore the GitHub interface, understand repositories, commits, the readme, issues, pull requests, forks, and stars, and see how actions automate releases and tests.

Explore GitHub account types—personal, organization, and enterprise—and learn how personal accounts enable repositories and collaboration, while organization accounts group repositories for teams and enterprise enforces single sign-on and two-factor authentication.

Explore GitHub pricing options, starting with free plan offering unlimited public and private repositories and 2000 minutes of CI/CD, then team and enterprise tiers with branch protection and code approvals.

Create a GitHub account by signing up on github.com with email and password, choosing a unique username, solving a puzzle, verifying email, and starting a project to connect with developers.

Learn how to connect to GitHub using ssh, generate and add an ssh key to the agent and GitHub, and verify authentication to push changes.

Discover how GitHub enables collaborative project work with git, create a GitHub account, and connect securely to your account via SSH.

Explore the nitty gritty of github by working with repositories and examining the features that make github a valuable collaborative tool for software development.

Explore how repositories on GitHub store code and history, support issues, pull requests, remote repositories, and push changes to share progress with public or private access.

Create your first repository on GitHub, choose public or private, initialize a local repo with git init, commit changes, and push to the remote origin on the main branch.

Explore a public repository, inspect account and repository details, review the main branch, commit history, and filters for branch, user, and time, and prepare to create a second commit.

Make a second Git commit by adding a file, staging changes, and pushing to the main branch, then explore the commit history and browse the repository at a previous commit.

Learn how to update a file directly on GitHub, commit to the main branch or create a pull request, and review diffs and history to see how content evolves.

Pull changes from the remote repository into your local workspace with git pull, syncing updates from origin main and updating your local commit history.

Create and manage branches in GitHub by creating a develop branch from main, switching and syncing locally, adding and pushing changes, and preparing for a pull request.

Explore how to collaborate with pull requests to propose changes from develop to main, describe the changes, review for conflicts, and merge or close without merging.

Download a zip to get project files without history, branches, or commits; compare with clone for history; demonstrate downloading from main and develop branches and extracting the folder.

Clone a repository to download files, branches, and commit history with git clone. Switch branches, create and switch to branches, pull changes, push commits, and merge via a pull request.

Learn how to create a local branch, switch branches, commit changes, push to GitHub, and merge via a pull request.

Create a readme at the project root to present your project using markdown, and manage changes with branches, commits, pull requests, merging, and branch deletion on GitHub.

Create a template repository to generate standard projects, add a readme, gitignore, and license, mark as a template in settings, and build new repositories from that template.

Explore issues in a repository as a forum for messages and tasks. Create, label, assign, and close issues; link them to pull requests and organize work with projects and milestones.

Learn how to link a GitHub issue to a pull request to track work and automatically close issues when the pull request is merged, using practical steps from this example.

Master milestones by linking issues and pull requests to version 1.0 goals, track progress from 0% to 100%, and learn how milestones organize work in GitHub projects.

Create and manage a GitHub project board to track tasks across repositories, convert items to issues, assign teammates, and move tasks from to do to done.

Fork a repository to create a copy under your account, edit files, commit to the main branch, and open a pull request to propose changes to the original owner.

Create a private repository on GitHub, invite collaborators, and understand write access and branch protections on the free account.

Work with GitHub repositories, create unlimited public and private ones, edit files, and use pull requests, issues, and projects to collaborate and manage tasks.

Learn Markdown basics to write rich text in repositories, including readmes, issues, and pull requests.

Explore markdown as a simple language for creating rich text, used in issues and pull requests on GitHub, with platform-specific tweaks and basics.

Learn to create markdown headers (h1 to h3) and apply bold, italics, and strikethrough. Build installation guides for Windows and Linux and commit changes to the main branch.

Explore how to display code using inline and block formats with backticks, and preview syntax highlighting for languages like C sharp and HTML within markdown in issues and pull requests.

Learn to display links in a GitHub issue using markdown syntax [text](url). Preview your link and navigate to the linked website.

Learn to insert and display images and gifs to clarify instructions, select graphics like the React logo, and submit content within issues.

Explore markdown lists in issues and previews, including unordered, ordered, and task lists, and learn how to track and complete steps within an issue.

Create markdown tables with a slash command to insert the necessary code efficiently. Preview headers, columns, and rows to organize data, as shown with example names and details.

Learn markdown basics to write rich text with a simple format, using headers, links, code, images, lists, and tables to express ideas clearly.

Explore an introduction to GitHub actions and how they automate tasks in GitHub. Learn how these actions streamline workflows and save time by automating repetitive GitHub tasks.

Learn how continuous integration verifies that team members' changes compile and pass automated tests when merged, and how continuous delivery prepares deployment or downloads with optional automation using GitHub Actions.

GitHub actions automate tasks in GitHub, from code compilation to pushing to servers and creating downloadable executables, using workflows and thousands of reusable actions beyond continuous integration and delivery.

Configure a GitHub action as a workflow written in YAML inside your repository, defining jobs and steps that automate tasks triggered by pushes, pull requests, manual, or periodic events.

Understand GitHub actions pricing for public versus private repositories. Public repos stay 100% free, while private repos offer 2000 free minutes per month and multipliers for Linux, Windows, and macOS.

Learn to create your first GitHub workflow from scratch by setting up a repository, adding actions, and writing a hello world YAML workflow that runs on push.

Learn how pushing changes to a repository triggers a GitHub Actions workflow, demonstrated by cloning a repo, editing a readme, committing, pushing, and watching the workflow run.

Configure a GitHub Actions workflow to run only on the main branch by editing the YAML to push branches: main, then validate changes via commits and pull requests.

Trigger and run a GitHub Actions workflow manually with a workflow dispatch button. Edit and commit changes to enable manual execution, select the main branch, and review run results.

Learn how to fetch and display repository files in a GitHub Actions workflow by using the official checkout action, exploring actions marketplace, and listing files in the console.

Learn how GitHub Actions automate tasks, enable continuous integration and delivery, and define workflows in YAML to respond to events like pushes or manual triggers.

Explore workflows to automate tasks in your repositories and streamline development processes. Learn the basics in this module and start implementing automation with GitHub Actions.

Learn to write YAML files, using indentation to indicate hierarchy, unquoted strings, and dash lists; discover workflow structures with on, jobs, runs-on, steps, and branches like main, develop, feature.

Learn how GitHub actions triggers work, including webhooks, schedule, and manual modes; see pull requests trigger workflows, restrict runs by path, and how YAML changes affect execution.

Trigger a workflow when a new issue is opened, using an issues example that runs on ubuntu latest and displays the issue title with the GitHub event issue title.

Learn how to trigger GitHub workflows with scheduled events using cron expressions for minute, hour, day of month, month, and day of week, and explore increments, ranges, and specific times.

trigger a workflow manually with workflow dispatch, define text and build type inputs, and pass values to run debug or release builds via the GitHub interface.

Learn to define multiple jobs in a GitHub Actions workflow, run them in parallel or in sequence, and manage cross-platform runners like Ubuntu, macOS, and Windows Server 2022.

Configure a GitHub actions workflow to run a single job across multiple configurations using a matrix strategy across Windows, Linux, and macOS.

Define variables in GitHub workflows to centralize configuration, using environment, job, and step scopes, and apply the least privilege principle for secure access.

Explore workflow expressions that evaluate values with the dollar sign and double squiggly brackets, access properties by dot or square bracket notation, and use operators and helpers such as success.

Explore using a matrix strategy in GitHub Actions and conditionally run a step on Windows with an if expression, while a common step runs on all operating systems.

Learn to use workflow commands in GitHub Actions to display warnings and errors as annotations, creating and testing a workflow with runs on Ubuntu, and viewing results in the summary.

Pass values between steps in a GitHub Actions workflow by using a step id and GitHub output, then access it in a subsequent step while masking secrets when needed.

Explore how to pass values from GitHub Actions to applications using environment variables. Access the variables in JavaScript with process.env and print them to the console.

Explore using variables and secrets to store centralized values, create repository variables and secrets, and access them in GitHub actions workflows via environment variables.

Learn how workflows function in Git, GitHub, and GitHub Actions by exploring triggers, jobs, and workflow commands, including printing, warnings, errors, masking values, and using variables and secrets.

Implement continuous integration and continuous deployment with GitHub actions to automatically deploy your application from source code.

Learn to implement continuous integration and delivery with GitHub actions for a sample ASP.NET core MVC app, including CRUD operations, tests, and database deployment.

Fork a repository and build a dotnet project with a GitHub actions workflow named compile and deploy, using checkout, setup dotnet, dotnet restore, and dotnet build.

Configure a GitHub Actions workflow to run on pushes restricted to the main branch, using path filters for workflows, app, and readme to trigger only relevant changes.

Modify the workflow to run automatic tests after compiling, commit changes, and run dotnet test no build; break tests, fix by uncommenting code, and verify tests pass in GitHub actions.

Publish your .NET app in a CI workflow and enable downloads of the produced artifacts using the build artifact action.

Learn how to create releases, zip artifacts, grant workflow permissions, and publish downloadable builds to GitHub releases.

Configure the workflow to create releases only when a tag is pushed. Check that the push reference starts with refs/tags and gate release steps accordingly.

Create a local git tag for version 10.0.1 and push it to the remote. Observe the GitHub Actions workflow run and the resulting release for version 1.1.

Learn to deploy an ASP.NET Core web app to Azure using GitHub Actions, including creating an app service, configuring secrets with the publish profile, and automating deployment.

Set up a new sql database and server in Azure, configure networking to permit GitHub Actions, capture the connection string, configure environment variables, and enable migrations through the workflow.

Learn to update an Azure SQL database from GitHub Actions by generating an idempotent migrations script with the EF Core CLI, storing it as an artifact, and deploying automatically.

Pull the latest changes, edit index.cshtml, commit, and push to trigger GitHub actions, which builds, tests, and deploys to Azure App Service.

Configure a continuous integration workflow that triggers on pull requests to main. Focus on compile and test steps using dotnet in GitHub Actions.

Learn to implement continuous integration and continuous delivery using workflows that compile projects automatically, run automated tests, create releases, and deploy applications to servers from the repository.