Git from the Bottom Up – The Index

This episode, we learn more about Git’s Index and compare it to other version control systems while Joe is throwing shade, Michael learns a new command, and Allen makes it gross.

The full show notes for this episode are available at https://www.codingblocks.net/episode194.

News

• Want to help out the show? Leave us a review!
• Ludum Dare is a bi-annual game jam that’s been running for over 20 years now. Jam #51 is coming up September 30th to October 3rd. (ldjam.com)
  • We previously talked about Ludum Dare in episode 146.

The Index

Meet the Middle Man

• The index refers to the set of blobs and trees created when running a git add, when you “stage” files.
• These trees and blobs are not a part of the repository yet!
  • If you were to unstage the changes using a reset, you’d have an orphaned blob(s) that would eventually get cleaned up.
• The index is a staging area for your next commit.
• The staging area allows you to build up your next commit in stages.
• You can almost ignore the index by doing a git commit -a (but shouldn’t).
• In Subversion, the next set of changes is always determined by looking at the differences in the current working tree.
• In Git, the next set of changes is determined by looking at your index and comparing that to the latest HEAD.
  • git add allows you to make additional changes before executing your commit with things like git add --patch and git add --interactive parameters.
  • For Emacs fans out there, the author mentioned gitsum. (GitHub)

Taking the Index Further

• The author mentions “Quilt!”, is it this? (man7.org)
  • The primary difference between Git and Quilt is Git only allows one patch to be constructed at a time.
• Situation the author describes is: What if I had multiple changes I wanted to test independently with each other?
• There isn’t anything built into Git to allow you to try out parallel sets of changes on the fly.
  • Multiple branches would allow you to try out different combinations and the index allows you to stage your changes in a series of commits, but you can’t do both at the same time.
  • To do this you’d need an index that allows for more than a single commit at a time.
  • Stacked Git is a tool that lets you prepare more than one index at a time. (stacked-git.github.io)
  • The author gives an example of using regular Git to do two commits by interactively selecting a patch.
  • Then, the author gives the example of how you’d have to go about disabling one set of changes to test the other set of changes. It’s not great … swapping between branches, cherry-picking changes, etc.
• If you find yourself in this situation, definitely take a look at Stacked Git. Using Stacked Git, you are basically pushing and popping commits on a stack.

Resources we Like

• Git from the Bottom Up by John Wiegley (jwiegley.github.io)
  • The Index: Meet the middle man (.css-j9qmi7{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;font-weight:700;margin-bottom:1rem;margin-top:2.8rem;width:100%;-webkit-box-pack:start;-ms-flex-pack:start;-webkit-justify-content:start;justify-content:start;padding-left:5rem;}@media only screen and (max-width: 599px){.css-j9qmi7{padding-left:0;-webkit-box-pack:center;-ms-flex-pack:center;-webkit-justify-content:center;justify-content:center;}}.css-j9qmi7 svg{fill:#27292D;}.css-j9qmi7 .eagfbvw0{-webkit-align-items:center;-webkit-box-align:center;-ms-flex-align:center;align-items:center;color:#27292D;}