Git and GitHub - The Complete Guide (for busy developer)

Learn how to initialize a git repository with git init to start tracking changes in files and folders, including empty directories.

Initialize a local git repository in a project folder using git init and verify with git status. Track files like index.html and observe the .git folder and the master branch.

Initialize a git repository in the project folder, add index.html, and track it with git status on the master branch, revealing the .git folder in Visual Studio Code.

Learn how to use the git clone command to copy a remote repository, such as one on GitHub, to your local machine so you can start working.

Explore staging changes with git stage, using the staging area to select files (file one, file three, or all) and commit them separately to the local repository.

Understand how to stage changes and use the commit command to create a new commit in the local git repository, generating a unique ID and updating the local GitHub.

Run git status to inspect repo, then stage the untracked index.html with git add and commit with a meaningful message. This creates your first git commit on the master branch.

Stage changes, track untracked files, and commit with meaningful messages using git add, git status, and git commit; learn to add all with a dot and use the -m option.

Discover how git log reveals commit history with full commit IDs, authors, and messages, and use git log --oneline for a condensed overview.

Push local changes to the remote repository with git push to synchronize your local GitHub with github.com, making the remote the ultimate source of truth.

Link your local Git repository to a new GitHub repository, push commits to origin, and authenticate to synchronize code with a remote repository.

Explore how changing global git configuration affects commit authorship on GitHub. Practice adding, committing, and pushing changes with different usernames and emails.

Use git pull to update your local repository from the remote repository after a coworker pushes changes; it fetches updated or added files and merges them, avoiding re-cloning.

Learn how to pull changes from a GitHub remote repository to your local machine with git pull origin master, then verify updates in your editor.

Compare git fetch and pull, showing how fetch updates the local GitHub without changing your workspace, while pull updates both the local repository and workspace.

Explore git's four stages: local workspace, staging area, local repository, and remote repository, by cloning a repo, editing, staging, committing, pushing, then fetching or pulling to update your workspace.

Understand why pushes fail when the remote repository has newer changes, then pull incoming changes before pushing your updates, a common sync pattern used by editors like Visual Studio.

Define head as the pointer to the most recent commit on the active branch, and see how switching branches, including master and new branches, updates head with commits.

Learn to use branches to develop new features and bug fixes without affecting the main repository, and merge commits back to the master branch.

Learn how branches and merges on the master branch coordinate services, FAQ, and about us page as two developers work, and how git resolves conflicts to finalize updates.

Create and switch to a new feature branch to develop the contact us page, then stage, commit, and observe how git tracks changes across branches.

Create and rename branches from master, switch with git checkout, commit changes, and safely delete branches using git branch -d or -D, depending on merge status.

Master a safe merge workflow: merge master into the contact us page branch, then merge into master and delete the branch after verifying functionality.

Create and switch to a new branch with git checkout -b, verify the current branch with git branch, and delete a temporary branch using git branch -D.

Explore using git switch to toggle between branches, create new branches with -c, and avoid git checkout, including practical examples from master to services page and branch deletion rules.

Explore how merge conflicts arise when two branches update the same lines in index.html and learn how to resolve them manually during a master branch merge.

Learn to resolve merge conflicts by merging master into a feature branch, using VS Code's merge editor to pick the right changes, and then completing the final merge into master.

discover how fast forward moves the main branch to the feature branch tip when there is no divergence, yielding a clean linear history; without it, a merge commit is created.

Create a new repository, initialize git, and make multiple commits with git add and git commit, review history with git log, and confirm head points to master.

Amend the last commit locally by staging changes and running git commit --amend. Only if not pushed to remote, use git status, git add, and consider renaming the commit message.

Use git checkout to time travel to a previous commit, inspect the code, then return to master, and learn how detached head state enables experimental changes and merging branches.

Understand how a detached head lets you explore past commits by pointing head directly at a commit rather than a branch; create branches to preserve experimental changes and merge later.

Learn to revert uncommitted changes with git restore, restoring specific files or all files to the last commit, and understand why git restore replaces git checkout for discarding changes.

Master git reset to move the current branch to a prior commit using mixed, soft, and hard options. Learn how each affects the working directory and staging area.

Use git revert to undo a specific commit without changing history, by creating a new revert commit. Prefer revert over reset to handle production bugs safely.

Learn to use a gitignore file to ignore build artifacts like logs, dlls, and bin, debug, and release folders in dotnet and Visual Studio projects, with predefined templates.

see gitignore in action as you add files like style.css and db.log, then configure patterns to ignore logs and a debug folder, clear cached files, and commit the gitignore.

Use the remote repository as the source of truth by git cloning to a fresh copy when local work is messy, then push only when confident.

Learn how git tags mark specific commits, enabling milestone, bug fix, and feature releases and providing easy rollback by tagging production releases in your git history.

Learn to create tags for releases, add a tag message, push tags with git push origin --tags, view tags, and check out tagged commits to manage releases.

Demonstrates the difference between git fetch and git pull, showing how fetch retrieves changes into origin, switches to master, and explains detached HEAD when checking out origin master.

Save uncommitted changes to the stash with git stash, then switch branches without losing work. Restore changes with stash pop or stash apply to the workspace.

Master how to stash and restore changes across branches using git stash, including stashing untracked files with -u, and the apply versus pop workflows.

Learn to create and review pull requests on GitHub, compare branches with master, merge changes, and track issues with labels, comments, and notifications.

Learn to resolve merge conflicts on GitHub by using pull requests, the GitHub editor, and branch cleanup to merge master with feature branches.

Fork a public repository to create a copy under your GitHub account, then clone the fork locally with git clone. Learn about copying only the master branch or all branches.

Clone a repository, examine its history with git log, and contribute to an open source project by forking, committing, pushing, and creating a pull request for review.

Explore how to create and push a git repository from a Visual Studio 2022 project, using an ASP.NET core MVC app with dotnet eight, and manage gitignore and git attributes.

Explore the essential git tabs in Visual Studio, including git changes and git repository, to track commits, branches, and GitHub interactions on the master branch.

Clone an existing repository to your local machine with Visual Studio 2022 by pasting the URL, then browse GitHub or Azure DevOps and view commits.

Stage changes, commit them separately in Visual Studio, review diffs, and push updates to the remote repository, managing outgoing commits and ensuring local history syncs.

Learn to fetch incoming changes and pull them into your local workspace using Visual Studio, inspect commits, and apply updates from the remote repository to keep your project synchronized.

Stashing all changes saves your in-progress work when a critical bug appears, letting you fix it and reapply changes with apply or pop.

Create and manage branches from the master branch to develop features like about us and FAQ, fetch remote branches, switch contexts, commit changes, and push to the remote repository.

Merge master into the faq feature, pull updates, resolve conflicts with the merge editor, then merge the feature into master and push.

Delete the merged branch from the origin to remove it from the remote repository and GitHub. This practice keeps the project clean by removing old branches from the remote.

Create a feature branch, push to remote, and open a pull request for code review, assign collaborators, and merge the services feature into master after review.

Learn to view and compare commits across branches, inspect file changes, and use base and compare views to identify updates in Git and GitHub.

Explore how to view a file's history, identify the exact commit updates, compare commits for a single file, and use blame to see who and when changed it.

Explore dotnet core mvc fundamentals from ground zero, build multiple applications, and master mvc and razor pages with practical debugging and up-to-date guidance for authentication and real-world projects.

Explore the evolution of dotnet core from web forms and mvc to a cross-platform, cloud-ready framework with built-in dependency injection and fast, open-source updates.

Install dotnet eight preview and Visual Studio 2022 preview to follow along, using windows x64, and note that dotnet seven is compatible except for date only and time only types.

Get started with essential prerequisites: basic c# knowledge, sql server experience with simple sql statements, and a grounding in dotnet core mvc.

Set clear expectations for prerequisites, including a basic understanding of C# and .NET core mvc, plus familiarity with SQL server queries like select and delete.

Dependency injection uses a container to inject interfaces like IDB and email with their implementations, enabling loose coupling across pages. Dotnet framework registers services and handles object creation.

Get an overview of building a real-world dotnet core app with repository pattern, unit of work, api controllers, razor pages, and security.

Create an ASP.NET Core MVC web app in Visual Studio 2022, name the project and solution, set dotnet eight, and push the initial code to a private git repository.

Walk through the bulky web project, run and inspect the app, and explore the dotnet 8 project file, including implicit using, nullable basics, and how NuGet and npm packages integrate.

Explore how launch settings and profiles in launchSettings.json control running a .NET app, including http/https profiles, environment variables, and ports, with practical examples like dev vs production keys.

Explain how the wwwroot folder hosts static content such as css, javascript, and libraries like bootstrap and jquery, and how appsettings.json stores secrets and connection strings, including environment-specific appsettings.production.json.

Program.cs consolidates startup.cs and configuration in dotnet core, showing how to add services and configure the MVC request pipeline with a default route.

explains the mvc architecture, focusing on models, views, and controllers, and how the controller fetches data from models and renders it in the view through routing.

Explore routing in an MVC application by mapping URLs to a controller, an action, and an optional id, and examine the default route configured in Program.cs.

Learn how routing in MVC maps URLs to a controller and action, with views organized by controller, using the home controller, index and privacy actions, and default routes.

See how default views in MVC rely on an underscored layout as the master page, with render body, partial views, and view imports guiding shared content.

Define a category model in Entity Framework Core, with properties id, name, and display order, and mark id as the primary key using data annotations.

Explore how data annotations like [Key] and [Required] designate primary keys and not-null fields in EF Core, and learn to configure a connection to SQL Server to create tables.

Install three NuGet packages for EF core: Microsoft Dot Entity Framework Core, Microsoft Dot Entity Framework core dot SQL Server, and Microsoft Dot Entity Framework core dot tools, ensuring alignment.

Add a connection string to your project by configuring appsettings.json under connection strings with default connection, including trusted_connection and trust server certificate, for local sql server via program.cs.

Configure Entity Framework Core by creating an application DbContext, wiring a constructor with options, registering the context in Program.cs, and using SQL Server with a connection string from appsettings.json.

Configure the entity framework core DbContext and connection string, then create a database with update-database, handling migrations and migrations history to establish the bulky database and its first table.

Create a category table with Entity Framework Core by defining a model, adding a DbSet in the application db context, and running a migration to update the database.

Learn to implement CRUD operations for categories by adding a category controller and an index view in an mvc app, wiring routing to display the category list.

Add a category link in the header by using tag helpers to point to the category controller's index action, enabling navigation to categories without manual URLs.

Seed the category table by overriding on model creating with a model builder, add three categories (action, sci fi, history), then migrate and update the database.

Retrieve all categories from the database using the application db context and Entity Framework Core, inject the context in the controller, and pass the list to the index view.

Render the category list as a bootstrap table with category name and display order, and leverage dotnet seven hot reload to auto-refresh view changes on file save.

Learn how to display a list of categories in an MVC view using a controller-passed model, iterating with C# in the view, and ordering by display order.

Apply Bootswatch themes to bootstrap CSS, switch to the Lux theme, and darken the header, footer, and navbar with a primary background. Add bootstrap icons via CDN to the layout.

Display the category list in a bootstrap grid, with a left column heading and a right column create button that navigates to a dedicated create category page.

Create a new category by adding a create action and view in the category controller, then design a responsive form with name, display order, and a submit button.

Explore how asp-for tag helpers in dotnet core simplify binding input fields for category name and display order, auto-detect types, and improve client-side validation with display name annotations.

Learn how to create a new category using a form post, Entity Framework Core, and a DbContext, including adding the category, saving changes, and redirecting to the index view.

Implement server-side validation for a category model with required, range, and max length data annotations. Utilize tag helpers and model state checks to display validation errors and messages on create.

Implement custom validations beyond data annotations by comparing the name and display order in the controller, then use model state errors and ASP validation summary tag helper to display messages.

Learn how the asp validation summary shows all, model only, or none errors, including custom validation, with a login example illustrating global versus property validations.

Enable client side validation in a .NET Core app with validation scripts, a shared partial view, and the partial tag helper to display immediate feedback before server checks.

Learn how to add edit and delete buttons to the category index view using bootstrap icons, including a pencil for edit and a trash icon for delete, with btn-group styling.

Design and implement the category edit page that mirrors the create view, pass the selected id via routing, and retrieve the category with multiple EF Core methods (find, firstordefault, where).

Learn how to scaffold and edit categories using razor views, update actions, and Entity Framework Core, with client-side validations and post methods.

Update category functionality demonstrated through editing actions, ID handling, and hidden input considerations to avoid creating new records in Entity Framework Core, followed by deleting a category.

Delete a category by implementing get and post actions, retrieving the category by id, renaming the post method to delete, setting endpoint name, and saving changes and returning to index.

Add a delete view, disable fields in the delete form, pass the route id for deletion, and verify the crud operations for categories with the delete action.

Learn how TempData in dotnet core enables transient notifications after create, edit, or delete actions by storing a message before redirecting to category list and displaying on the next render.

Reuse temp data notifications across multiple pages with a single partial view to display success and error messages, placed in the shared folder and consumed with one line of code.

Implement toaster notifications with the Toastr library, displaying success messages, using CDN assets and jQuery, and move the logic into the underscored layout as a reusable partial view across pages.