Git and GitHub - 0 Experience to Professional in 1 Tutorial (Part 1)

Git is an essential tool in software engineering, functioning like the version history feature in Google Docs or Microsoft Word. It allows developers to save and access past versions of their code files, providing a safety net for restoring previous states if needed. Beyond basic version control, Git offers advanced features such as branching and integration with platforms like GitHub that elevate its utility to professional levels.

To install Git, visit git-scm.com/downloads and select your operating system. For macOS users, follow the specific instructions provided for installation. Windows users can skip to their designated section in the tutorial.

To install Git on macOS, the recommended method is through Xcode. Open Spotlight to access Terminal and type 'git'. If a message confirms installation, you're set; otherwise, follow prompts to install it or download Xcode from the App Store. After installing Xcode, open it once before restarting Terminal and typing 'git' again for confirmation.

Installing Git on Windows is straightforward. Navigate to the designated section, and the installer will download automatically; if not, a manual link is provided. Once downloaded, run the installer with default settings by clicking 'Next' until completion. Open PowerShell afterward and type "git" to confirm installation—if successful, a confirmation message appears.

To begin using Git for version control, create or use an existing project. On both Mac and Windows, the process is identical. Start by creating a folder named "git-tutorial" on your desktop to house practice code. Open this folder in your preferred code editor and write simple example code with console.log statements indicating file name and version number to track changes effectively.

Git is primarily used through the command line, accessible via Terminal on Mac or PowerShell on Windows. To begin, open these tools and understand that commands are executed within a specific folder context. Initially starting in the $HOME folder, users must navigate to their code directory using 'cd' (change directory) followed by its path. Verifying location accuracy can be done with 'ls', which lists files and folders in the current directory. Always remember to reset your working directory after restarting your command line tool.

Initializing Git and Tracking Changes To start version control, initialize Git in the project folder using 'git init'. This sets up tracking for all files within that directory. Use 'git status' to view untracked changes; initially, new files like config.js or folders such as src will appear. To prepare specific changes for a commit, use 'git add', either specifying individual items or adding everything with 'git add .'. Verify added items again with another run of 'git status'.

Creating Commits and Configuring User Details 'Git commit -m "message"' creates a new version (commit) in your history while attaching an explanatory message about the change. If errors occur due to missing user details, configure them by running commands: set email via `git config --global user.email` followed by name setup through `--global user.name`. Once configured properly, re-run the git commit command successfully completing your first tracked version.

Two files were modified with four lines of code added, but a warning appeared due to missing username and email configuration in Git. Configuring these details ensures accountability for changes made by team members. The version history can be viewed using 'git log,' showing commit messages along with author information; however, default values are used if the configuration is done post-commit creation. Mistakes like misspelled commit messages or forgotten file additions can be corrected using 'git add' followed by 'git commit --amend.' This command updates the previous commit instead of creating a new one while maintaining an accurate version history.

Modern code editors, like Visual Studio Code, offer built-in Git integrations that allow developers to visualize tracked changes directly within the editor. This feature enables users to see modifications made since the last version and compare them file by file without relying solely on command-line tools. For instance, instead of typing commands like 'git add,' users can simply click buttons within the interface for a more streamlined workflow.

Understanding Git's Staging and Working Areas Git organizes changes into two areas: the working area, where all modifications start, and the staging area, which holds selected changes for inclusion in the next version. Using 'git add', you move specific updates from the working to staging area. However, since Git tracks individual changes rather than entire files, a file can simultaneously exist in both areas if it has unadded modifications.

Resetting Changes with Git Commands or Editor Integration 'Git reset' removes specified files or folders from the staging area back to working without affecting their content; using '.' resets everything within your current directory. To undo edits entirely in your working directory use 'git checkout --'. Code editors often simplify these processes through integrated buttons that replicate these commands efficiently.

Creating versions manually in Git ensures that only functional and complete code is saved, unlike Google Docs which automatically saves all changes regardless of completion. This approach prevents errors from being stored as part of the version history. To practice this process, one can modify code, stage changes using 'git add', and commit them with descriptive messages like "version 2" or "version 3." Running 'git log' confirms the addition of these new commits to the version history.

To view a previous version of code, use the 'git checkout' command followed by the specific commit hash, which serves as an identifier for that version. This allows reverting to earlier states efficiently, even when multiple files are involved. The current active version is marked by 'HEAD,' indicating where you are in your project's history. To see all commits across versions rather than just those behind the current one, run 'git log --all.' Switching between versions provides flexibility and clarity while managing changes.

To restore code to a previous version, the process mirrors Google Docs' "restore this version" feature but utilizes git. After reverting back to an earlier state (e.g., version 1), modifications can be made and new commits created as usual. By performing updates, staging changes with 'git add,' and committing them under descriptive messages like "version 1 updated," the restored code integrates seamlessly into the commit history without disrupting prior versions.

Git branching occurs when you revert to a previous version and start adding new changes, creating separate branches in the history. Unlike Google Docs, which simply copies over the document's state without branching, Git visually represents these divergences using commands like 'git log --graph'. This command displays multiple commit branches stemming from earlier versions. Branch names simplify navigation by pointing to the latest commits within their respective branches and allow easy switching between them with commands such as 'git checkout [branch name]'. While this feature is central to how Git operates, it differs fundamentally from linear version histories seen in tools like Google Docs.

The process of restoring code versions, similar to Google Docs' restore feature, can be achieved using the 'git checkout' command. This requires specifying a commit hash for the desired version and selecting files or folders to revert without altering branch history or moving HEAD. For example, running 'git checkout config.js' restores only that file's content from a specific version while keeping other changes intact; similarly, entire directories can be restored by providing their paths. After restoration via git checkout, affected files are automatically staged for committing. To finalize these changes in your repository’s history without creating branches or disrupting existing commits: run `git commit -m "version X restored"`. The approach ensures seamless integration into ongoing development workflows.

Git aliases simplify command usage by allowing shortcuts for frequently used commands. For example, instead of typing 'git status,' you can set up an alias like 'git s' to achieve the same result. This is done using the git config global alias command followed by your desired shortcut and its corresponding full command. Commonly used aliases include 'cm' for commit -m and 'co' for checkout, significantly speeding up workflow efficiency.

To prevent sensitive files, like those containing passwords or private data, from being added to version history in Git, a file named '.gitignore' can be created. This file specifies which files should be ignored by Git during tracking and commits. For example, adding 'secrets.txt' into the '.gitignore' ensures it won't appear in your repository's history while still allowing you to track changes for other necessary files.

To completely remove Git tracking and version history from a project, first create a backup copy of the project to preserve your files. Navigate into the copied folder using the command line and confirm that it is still being tracked by running 'git log'. To delete all traces of Git, execute 'rm -rf .git', which removes the hidden '.git' directory containing all repository data. After this step, attempting any git commands like 'git log' will indicate that it's no longer recognized as a repository.

This tutorial focuses on creating online backups of code using GitHub, exploring its features in depth. It aims to make tech careers accessible by providing clear guidance and resources like a cheat sheet for commands covered. For further questions or feedback, viewers are encouraged to reach out through the provided contact link.