Git: The Tool I Wish I Had Learned Before My First Hackathon
Introduction
When I started engineering, I thought Git and GitHub were basically the same thing. I knew developers used them, but I never felt the need to learn them. My projects were small, usually consisting of a few files, and whenever I made changes, I simply created another copy with names like final, final_v2, or latest_final.
Everything seemed manageable until I participated in Smart India Hackathon (SIH). That was the first time I worked on a large project with multiple teammates, multiple files, and continuous changes. Looking back, I realize that many of the problems we faced were not because of coding mistakes—they happened because we had no proper system to manage our code.
The Problems We Faced Without Git
1. Too Many Versions, Too Much Confusion.
During SIH, different team members worked on different features. Whenever someone completed a task, they shared the updated code on WhatsApp.
Soon our chat looked something like this:
"Use this file." "Wait, I made some changes. Use this one."
"No, this is the latest version."
After a while, nobody was completely sure which file was actually the newest one. As the project grew larger, managing code through WhatsApp became confusing and inefficient.
2. One Change Could Break Everything
As teachers, mentors, and teammates suggested improvements, we kept modifying different parts of the project.
A small change in one file would sometimes affect another feature. Fixing one bug could create another bug somewhere else. Since we had no proper version history, tracking the source of the problem became difficult.
At one point, we spent more time figuring out what had changed than actually building new features.
3. No Way to Go Back
One of the biggest challenges was that we couldn't easily return to a previous working version.
If a new update caused problems, we had to manually compare files and try to remember what had changed. This wasted valuable time, especially during a hackathon where every hour matters.
Then I Learned Git
After SIH, I finally decided to learn Git. That's when I understood why developers consider it an essential tool.
Git is not just about storing code. It is a version control system that helps developers track changes, collaborate with others, and safely experiment without losing their work.
The best part is that Git solves almost every problem we faced during our project.
Understanding Git Through a Real-Life Example
Imagine we are writing a college assignment.
Git Add
Before submitting the assignment, we select the pages we want to include.
This is similar to git add. It tells Git which changes should be included in the next save point.
Git Commit
Now imagine saving our assignment with a note:
"Completed Introduction Section"
That's exactly what git commit does. It saves our work along with a message describing the changes.
Git Branch
Suppose we want to try a completely new design for our assignment but don't want to risk damaging the original copy.
We create a separate draft.
This is similar to git branch. It allows us to experiment safely without affecting the main project.
Git Merge
If the new draft turns out to be better, we combine it with the original assignment.
This is what git merge does. It brings changes from one branch into another.
How Git Would Have Helped During SIH
If we had used Git and GitHub during SIH:
Everyone could have worked on the same repository. We would always know which version was the latest. Every change would be recorded automatically. We could see who made each change. Bugs would be easier to track and fix. We could roll back to a stable version whenever needed. Collaboration would have been much smoother.
Instead of sharing code through WhatsApp, GitHub could have become our single source of truth.
My Biggest Learning
Earlier, I thought Git was something only professional developers used.
Now I understand that Git becomes important the moment a project starts growing. Whether it is a hackathon, college project, internship, or open-source contribution, managing code properly is just as important as writing code.
Learning Git gave me confidence to make changes, test new ideas, and collaborate without worrying about losing my work.
Conclusion
The biggest lesson from my engineering journey is simple:
Good code is important, but good code management is equally important.
Git doesn't just store your code. It helps you track progress, collaborate with teammates, recover from mistakes, and build projects with confidence.
If you're still managing projects with folders named Final, Final_Final, and Final_Updated, learning Git today might save you a lot of time and frustration in the future.
#Git #GitHub #VersionControl #SmartIndiaHackathon #EngineeringStudent #OpenSource #Programming #DeveloperJourney #LearningInPublic