How to Use Git and GitHub – Introduction for Beginners

As a developer, sooner or later you‘ll need to learn how to use Git and GitHub. These powerful tools help you manage your code, collaborate with others, and build an impressive portfolio of projects. But getting started can feel overwhelming at first.

Don‘t worry – by the end of this guide, you‘ll understand the key concepts and workflows of Git and GitHub. I‘ll walk you through the process step-by-step with clear explanations and practical examples. Let‘s dive in!

What are Git and GitHub?

Git is a distributed version control system. It helps you track changes to your code over time. With Git, you can roll back to earlier versions of your code if something goes wrong. You can also create branches to experiment with new features without impacting the main codebase.

GitHub is a web-based platform that works hand-in-hand with Git. It provides a centralized place to store and manage your Git repositories online. GitHub makes it easy to collaborate with other developers on open source and private projects.

So in a nutshell – you use Git to manage your code locally, and GitHub to store and share your code in the cloud. The two tools integrate seamlessly to supercharge your development workflow.

Why Learn Git and GitHub?

There are many compelling reasons to add Git and GitHub to your skillset as a developer:

Manage code effectively: Git helps you keep track of all the changes to your codebase. You‘ll have a clear history of your work and the ability to revert changes if needed. No more digging through endless folders of confusingly-named files!

Collaborate with others: Most real-world development projects involve a team of programmers working together. GitHub provides powerful features for collaboration, including the ability to contribute code, raise issues, and conduct code reviews.

Showcase your work: Your GitHub profile acts as a portfolio of your development projects and contributions. Recruiters and hiring managers routinely check GitHub to evaluate candidates. An active, well-maintained GitHub profile can open up exciting career opportunities.

Contribute to open source: GitHub is home to the world‘s largest open source community. You can browse millions of public repositories to learn from other developers‘ code. As you gain experience, you can even start contributing to open source projects yourself!

Key Differences Between Git and GitHub

Although Git and GitHub are closely related, there are some important differences to be aware of:

Git:

• Runs locally on your computer
• Manages source code versions
• Can be used without a GitHub account
• Primarily a command-line tool

GitHub:

• A cloud-based service for storing Git repositories
• Provides a web interface to view/manage your repositories
• Includes collaboration features like issues, pull requests, and project management tools
• Requires an account and internet connection to use

In practice, most developers use both Git and GitHub in tandem. But it‘s possible to use Git without GitHub, or even to use GitHub without the command-line version of Git.

Getting Started with Git and GitHub

Now that you understand what Git and GitHub are and why they matter, let‘s walk through the process of setting them up and using them for the first time.

Step 1: Install Git

First, you‘ll need to install Git on your local machine if you haven‘t already. The process is a little different depending on your operating system.

For Windows:

1. Download the Git for Windows installer from the official website: https://gitforwindows.org/
2. Run the installer and follow the prompts. The default options are usually fine.
3. Open the Git Bash application to start using Git.

For Mac:

1. Install the Xcode Command Line Tools by running this command in the Terminal: xcode-select --install
2. Alternatively, you can install Git via Homebrew by running: brew install git

For Linux:

• On Debian/Ubuntu: sudo apt install git-all
• On Fedora: sudo dnf install git-all

Once the installation finishes, you can verify Git is working by running this command in your terminal:

git --version

You should see the version number of Git printed to the console.

Step 2: Configure Git

Next, you need to configure Git with your name and email address. This information will be attached to all the commits you make.

Run these commands in your terminal, replacing the placeholders with your own info:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"  

You can check your Git configuration at any time by running:

git config --list

Step 3: Create a GitHub Account

If you don‘t have a GitHub account yet, head over to https://github.com/ and sign up. Choose a username, enter your email, and set a password.

GitHub offers free accounts for individuals and organizations. You can also upgrade to a paid plan to get additional features like private repositories.

Step 4: Create Your First Repository

A Git repository, or "repo" for short, is a container for your project files and all the versions of those files over time.

Let‘s create a repo for a simple website project:

1. In your terminal, create a new directory and navigate into it:

mkdir my-website
cd my-website

2. Initialize a new Git repo in the current directory:

git init

3. Create a simple HTML file:

echo "" > index.html 

4. Add the HTML file to the staging area:

git add index.html

5. Commit the changes with a message:

git commit -m "Add initial HTML file"

Congratulations, you‘ve just created your first Git repository and made your first commit!

Step 5: Push to GitHub

To back up your local repo and share it on GitHub:

1. Log in to GitHub and click the "+" icon in the top right corner.

2. Choose "New repository"

3. Enter a name for your repo and click "Create repository". You can leave the other options as default for now.

4. On the next page, you‘ll see instructions for pushing an existing repository to GitHub. Run those commands in your terminal:

git remote add origin https://github.com/your-username/your-repo-name.git
git branch -M main 
git push -u origin main

Replace your-username and your-repo-name with your actual GitHub username and repository name.

Refresh the GitHub page and you‘ll see your code appear in the browser!

Basic Git Commands and Workflow

Here‘s a quick reference for some of the most common Git commands you‘ll use:

• git init: Initialize a new Git repository
• git clone: Clone an existing repository from GitHub
• git add: Stage changes to be committed
• git commit: Commit the staged changes with a message
• git push: Push your local commits to the remote repository on GitHub
• git pull: Fetch changes from the remote repository and merge them into your local branch
• git branch: List, create or delete branches
• git checkout: Switch between branches
• git status: See the current state of your repository

The basic Git workflow looks like this:

1. Make changes to your project files
2. Stage the changes with git add
3. Commit the changes with git commit
4. Push the commits to GitHub with git push
5. Repeat!

Of course, this just scratches the surface of what you can do with Git. As you gain more experience, you‘ll learn advanced techniques like branching, merging, rebasing, and resolving merge conflicts.

Git and GitHub Best Practices

To get the most out of Git and GitHub, there are some best practices to keep in mind:

Write clear commit messages: Your commit messages should concisely explain what changed and why. Avoid vague messages like "fix bug" or "update file". Instead, use the imperative tense and focus on the what and why, like "Refactor login form to improve performance".

Commit early and often: Don‘t wait until you‘ve finished a huge chunk of work to make a commit. Frequent, small commits make it easier to track changes and roll back if needed. A good rule of thumb is to commit whenever you‘ve made a meaningful change that you might want to revisit later.

Use branches for new features and bug fixes: Branches let you work on different parts of your project without impacting the main codebase. When you‘re ready, you can merge your branch back into the main branch. This helps keep your main branch stable and makes it easier to collaborate with others.

Regularly pull from the remote repository: If you‘re working with others, it‘s important to pull changes from the remote repository often. This ensures you have the latest version of the codebase and minimizes merge conflicts. Get in the habit of pulling before you start working and before you push your own changes.

Protect your main branch: Your main (formerly "master") branch should always be stable and deployable. To prevent accidental pushes to main, you can enable branch protection rules in your GitHub repo settings. This way, changes must go through a pull request and review process before being merged.

Use a .gitignore file: You don‘t need to track every file in your project with Git. Compiled code, dependencies, and sensitive files like passwords should usually be excluded. You can specify files and directories to ignore in a .gitignore file. GitHub provides templates for common languages and frameworks.

Hands-On Git and GitHub Practice

The best way to get comfortable with Git and GitHub is through practice. Here are some ideas to try:

1. Create a new repo for a practice project or tutorial you‘re working on. Commit your changes as you go.

2. Contribute to an open source project on GitHub. Look for beginner-friendly issues to tackle, or submit a fix for a bug you encountered. Many projects have contributing guidelines and maintainers who are happy to help newcomers get started.

3. Collaborate with a friend on a small project. Create a shared repo on GitHub and practice the pull request workflow. Review each other‘s code and merge the accepted changes.

4. Explore GitHub repos for your favorite languages, frameworks and tools. Study how they use branches, tags and releases. Read through issues and pull requests to see how the maintainers communicate and make decisions.

5. Automate your development workflow with GitHub Actions. You can set up continuous integration and deployment pipelines to automatically test, build and deploy your code changes.

Git and GitHub Learning Resources

There‘s always more to learn about Git and GitHub. Here are some resources to continue your journey:

• Official Git documentation: https://git-scm.com/doc
• GitHub Guides: https://guides.github.com/
• Pro Git e-book: https://git-scm.com/book/en/v2
• Oh Shit, Git!?!: https://ohshitgit.com/
• Git Branching interactive tutorial: https://learngitbranching.js.org/
• GitHub Skills courses: https://skills.github.com/
• Git Cheat Sheet: https://education.github.com/git-cheat-sheet-education.pdf
• GitHub Training videos on YouTube: https://www.youtube.com/githubguides

Remember, everyone starts somewhere. Be patient with yourself as you learn, and don‘t hesitate to ask for help when you need it. The Git and GitHub communities are full of friendly developers who are happy to lend a hand.

Conclusion

Git and GitHub are essential tools for every developer to know. They help you manage your code, collaborate with others, and build a public portfolio of your work.

In this guide, you learned:

• What Git and GitHub are and why they‘re important
• Key differences between Git and GitHub
• How to install and configure Git
• How to create a repository on GitHub and push your code
• Basic Git commands and workflows
• Best practices for using Git and GitHub effectively
• Ideas for practicing your skills
• Resources to continue learning

Armed with this knowledge, you‘re ready to start using Git and GitHub in your own projects. Remember to commit often, write clear messages, and don‘t be afraid to experiment.

With practice and persistence, you‘ll soon wonder how you ever developed without these powerful tools. Happy coding!