• Home

  • Custom Ecommerce
  • Application Development
  • Database Consulting
  • Cloud Hosting
  • Systems Integration
  • Legacy Business Systems
  • Security & Compliance
  • GIS

  • Expertise

  • About Us
  • Our Team
  • Clients
  • Blog
  • Careers

  • VisionPort

  • Contact
  • Our Blog

    Ongoing observations by End Point Dev people

    Interactive Git: My New Found Friend(s)

    Brian J. Miller

    By Brian J. Miller
    March 29, 2011

    As a software engineer I’m naturally inclined to be at least somewhat introverted :-), combine that with the fact that End Point is PhysicalWaterCooler challenged and you have a recipe for two things to naturally occur, 1) talking to oneself (but then who doesn’t do that really? no, really.), 2) finding friends in unusual places. Feeling a bit socially lacking after a personal residence move, I was determined to set out to find new friends, so I found one, his name is “–interactive”, or Mr. git add –interactive.

    “How did we meet?” You ask. While working on a rather “long winded” project I started to notice myself sprinkling in TODOs throughout the source code, not a bad habit really (presuming they do actually eventually get fixed), but unfortunately the end result is having a lot of changed files in git that you don’t really need to commit, but at the same time don’t really need to see every time you want to review code. I’m fairly anal about reviewing code and so I was generally in the habit of running a git status followed by a git diff on every file that was mentioned by status. These are two great friends, but of late they just don’t seem to be providing the inspiration they once did. Enter my new friend git add --interactive. Basically he combines the two steps for me in a nice, neat controlled way while adding a bit of spice to my life, in particular per change inclusion capability. When running git add with the interactive flag you are provided with an overall index status immediately followed by a prompt. At that prompt you have an option of “5) patch”, by entering “5”, then return, you are then provided the index (basically) again. From that index you can select from a list of files for which you would like to review patches. For each reviewed patch you can then specify whether to include that patch for commit, skip it, divide (split) it into smaller patches for further review, or even edit it. When selecting the files to review the patches for it is simple to choose a range of files by entering a specifically formatted string, i.e. “1-12,15-18,19”. With –interactive the time it takes to review the code pending commit and skip through the TODOs is greatly reduced, something the client definitely appreciates.

    “But what about your other old friends?” You then ask. Well, as it turns out my spending so much time with interactive add made git stash feel a bit lonely, and it dawned on me that tracking those TODOs in the working tree at all may be a bit silly. What could a guy do, perhaps these two friends might actually like to party together? As it turns out they had already been introduced and do like to party together (not sure why they couldn’t have just invited me before, though it might have something to do with my past friendship with SVN and RCS). Either way, to once and for all get those unsightly TODOs out from under my immediate purview while keeping other changes I still needed in the index I found git stash save --patch --no-keep-index “TODO Tracking”. “save” instructs git stash to save a new stash, “–patch” tosses it into an interactive mode similar to the one described above for add, “–no-keep-index” instructs stash not to keep the changes in the working tree that are added to the created stash, and the “TODO Tracking” is just a message to make it easy for a human to understand what the stash contains (I made this one up for my specific immediate purpose). This leaves my working tree and index clean for me to do more pressing work and to know that when I have the time/need to restore those past TODOs I can, so that they may be worked on as well. Note that I’ve not really used this technique much (read: I’ve just done it now for the first time) so we’ll see if it really is that useful, but the interactive patching I’ve used and it is definitely worth it.

    As a further side bar I was discussing multiple commit indexes in a Git repo with someone in the #yui channel, and as soon as I found the above it occurred to me that using multiple stashes where you pop them could work in effect the same way, though I don’t know if there is a way to add patches to an already created stash. That might make a neat feature to investigate and/or request from the Git core.

    Just so you aren’t too concerned, there is still a place in my heart for git add and git status even if I don’t see them as frequently as I once did.