git is a command-line version control system. Version control means taking snapshots of files you’re editing at different stages of development. It’s almost like an undo-redo program with lots of extra features to navigate through your timeline of snapshots. Each snapshot is called a commit.
New programmers are encouraged to learn git early because team programming projects basically require the use of some kind of version control, and git is one of the most widely-used version control systems in the software industry today.
It’s also a good idea to use version control when doing solo work. I’ve found that the git workflow I use helps me prioritize paths of development and break up my work into digestible chunks. (Tangentially, version control is becoming increasingly popular among writers and other non-programmer vocations.)
My git workflow looks like this:
- Use my preferred text editor to make changes to one or more files in my project and save them normally
- Ask my terminal to list the changed files with
$ git status
- Add changed files to my ‘stage’ to be included in my snapshot with
$ git add [filename]
- Commit my changes with a message using
$ git commit -m "Descriptive message here"
But if you’re a first-time git user with little experience on the command line, you may try take a snapshot of your progress with this command:
$ git commit
Sounds simple right? What you don’t know is that the default behavior for
git commit is to launch your terminal’s default editor so you can write the mandatory commit message, since you didn’t include a message with the
-m flag like I did.
Remember earlier when I said that your terminal’s default editor is probably vim? Here’s the fun part.
Surprise, it’s vim!
Imagine being a freshman computer science student. You’ve been using the command line for a few months now but only in a few limited contexts. You’re far from comfortable with the teeny tiny text on the scary black screen.
Right now you have a deadline on a group project. This is your first time working with git because your annoying group leader (who made her the boss?) is making you use it. You don’t understand why she can’t just let you learn what you need for the project so you can get a decent grade.
She went through her fancy workflow but you just couldn’t deal with her annoying patronizing-ass voice so you zoned out the whole time. You’re already in lectures all day! Why do you need another one that won’t even count toward anything?
So you decided you’ll just do the project and figure out the git bullshit when you have to turn it in. Which is now.
You are here:
You’ve typed this:
$ git commit
When you hit
Enter you see this:
What you’re supposed to do
If you expected vim to open, you’d know you have to
ito switch to INSERT mode
- Type your commit message
ESCto switch to COMMAND mode
Enterto save and exit
What you actually do
But you’ve never heard of vim. You didn’t expect the whole screen layout to change. And now you’re hitting ESC ESC ESC and CTRL-Z and then you end up back where you were before with this message:
$ git commit + Stopped git commit $
You try it again
$ git commit
And are shown this:
Now you’re panicking. You feel a knot in your throat. Your eyes are starting to sting.
FUCK FUCK FUCK
You start frantically Googling… etc., etc.
An hour later you’re in tears, emailing the files to your group mates, trying to ignore the shame you’re feeling because you couldn’t get stupid git to work and everyone else could.
A hazing ritual
Like I said in my previous post: programming has lots of these hazing rituals. My first year studying CS, it took me four months to figure out how to open an existing project in Eclipse.
I’ve bawled my eyes out and torn my hair out and thrown things across the room. And then eventually you realize you just misread some small thing and it’s actually not that hard. But you still feel kind of superior for having figured it out yourself.
Yeah, maybe that isn’t the healthiest attitude to maintain. Programmers are weird.