Managing Your Code with Git and GitHub

As a Software Engineer, managing your code is a critical part of the development process. From adding new features to squashing bugs, all while ensuring your code is readable and ready for others to contribute, you need a robust system to keep track of all these changes. Enter Git and GitHub.

Before Git

Before adopting Git and GitHub, my workflow was chaotic. Every time I made a change, I’d end up creating a new folder to track that change. But keeping track of which feature was added in which folder was a nightmare. It was only after much frustration that I decided to learn Git and GitHub to streamline my development process.

The Significance of Git in Development

Git and GitHub offer indispensable benefits for developers:

Version Control: With Git, you can preserve multiple versions of your code, ensuring no data loss.
Collaboration: Publishing code on GitHub allows others to review, contribute, and enhance your projects.
Documentation: Adding documentation enables easy reference and understanding of your code, facilitating maintenance and troubleshooting.

Personal Insight

The real value of Git and GitHub became clear after I lost a significant amount of work due to poor version control. After a computer crash wiped out my work, I adopted Git and GitHub religiously. This change has safeguarded my code and projects ever since.

Understanding Git

Git, a powerful version control system, empowers collaboration and project management. Created by Linus Torvalds in 2005, Git is now widely used in both commercial and open-source projects. Its versatility across various operating systems and IDEs ensures that it’s deeply embedded in the development community.

Unveiling GitHub

GitHub, a dynamic code hosting platform, makes collaboration and version control effortless.

By allowing users to publish and share their projects, GitHub enables teams to collaborate, innovate, and collectively contribute to various software development projects.

Navigating GitHub Essentials for Seamless Development

Here are some key concepts you’ll need to master GitHub and version control for a smooth development experience:

Repositories

A repository on GitHub is the central place for storing and managing your development projects, ensuring smooth collaboration and version control.
Repositories contain various files, including code (HTML, CSS, JavaScript), documents, data, and images.
Essential files like README and license files provide important information about the project and its terms of use.

Branches

GitHub branches let you work on different versions of a project simultaneously, making development more organized.
The default branch is usually main, which should contain production-ready code. You can create new branches for feature development or bug fixes.
Once the feature or fix is ready, merge the changes back into the main branch to keep everything up to date.

Commits

Commits are individual changes made to the codebase, ensuring transparency and accountability.
Make sure to use descriptive commit messages so anyone reviewing your code can understand the changes you’ve made.

Pull Requests

Pull Requests (PRs) are used to propose changes to a project, allowing team members to review and discuss the code before merging it.
PRs show changes in a color-coded format (green for additions, red for deletions), making code review much easier.

Push Requests

Push requests are used to update your local repository with the changes from a remote repository on GitHub.
They allow you to sync your local development environment with the code that is deployed on GitHub.

Git Commands for Version Control

Here are some essential Git commands to get you started with version control:

Creating a Repository

To create a repository on GitHub:

Sign up or log in to GitHub.
Click the “New” button to create a new repository.
Fill in the repository details, including the name, description, and license.
After submission, your repository will be created, and you’ll be redirected to the repository page.

Cloning a Repository

To clone an existing repository to your local machine:

git clone <repository URL>

Creating a Branch

Create a new branch with the following command:

git checkout -b <branch_name>

Switching Branches

To switch between branches:

git branch
git checkout <branch_name>

Checking Status

To check the status of your repository:

git status

Adding Files

To stage files for a commit:

git add <file_name>
git add *

Committing Changes

To commit your changes with a message:

git commit -m "Your message here"

Pushing Changes

To push your changes to the remote repository:

git push --set-upstream origin <branch_name>
git push

Merging Branches

To merge one branch into another:

git checkout main
git merge <branch_name>

Pulling Changes

To pull the latest changes from the remote repository:

git pull origin main    # Pull changes from the main branch

By mastering these Git commands, you’ll improve your development workflow, simplify collaboration, and effectively manage your code.

Reverting Commits in Git

At some point, you might need to revert a commit that breaks your code. Here’s how you can revert commits from the main branch or any other branch.

Reverting a Commit from the Main Branch

If you need to revert a commit on the main branch, especially when it causes issues, follow these steps:

Identify the commit you want to revert by using:
```
git log
```
Once you find the commit hash, you can revert it using:
```
git revert <commit_hash>
```
This will create a new commit that undoes the changes from the selected commit.
Push the changes to the remote repository:
```
git push
```

Reverting a Commit from Any Branch

To revert a commit from any branch, you can use the same git revert command:

Checkout the branch where the commit exists:
```
git checkout <branch_name>
```
Identify the commit you want to revert using git log.
Revert the commit:
```
git revert <commit_hash>
```
Push the changes to the remote branch:
```
git push
```

Reverting Multiple Commits from the Main Branch

If you’ve committed multiple changes directly to the main branch and need to revert them, you can follow these steps:

To revert multiple commits, use the git log command to find the commit hash of the first commit you want to undo.
Use the git revert command with the range of commits to undo:
```
git revert <commit_hash_1>^..<commit_hash_n>
```
This command reverts all the commits between <commit_hash_1> and <commit_hash_n>, including both ends of the range.
Push the changes to the remote repository:
```
git push
```

Reverting Changes to Match a Backup Branch

If the code in your main branch breaks but you want to revert to the state of a backup branch, follow these steps:

Checkout the backup branch:
```
git checkout <backup_branch>
```
Merge the changes from the backup branch into the main branch:
```
git checkout main
git merge <backup_branch>
```
Push the changes to the remote repository:
```
git push
```

This will restore the code from your backup branch to the main branch.

Managing Application Versions with Release Pages

Understanding Versioning

Branches represent different versions of your application. Once features are developed and tested, they are merged into the main branch for deployment.

Leveraging Release Pages

Release pages help document each version of your application, including its features, bug fixes, and improvements.

Creating a Release

Go to the release page and fill in the relevant details for the new version.
After you’ve filled out all the information, hit the “Publish” button to make the release available on GitHub.

Final Thoughts

Git and GitHub are invaluable tools for developers. They help streamline code management, enable seamless collaboration, and ensure that you always have control over your project’s history. Don’t hesitate to reach out if you have any questions or thoughts on this.

I’d love to hear from you! Until next time! ❤️