Mercurial is Teh Awesome

My team at work recently switched from Subversion to Mercurial for revision control. That’s no small feat for a hardware design team (see: Averse to Change). It helps a little that we are mainly FPGA people (a lot “softer” than an ASIC), but there are still definitely hardware attitudes about change. Our software partners made the change a while ago, so they already had some process and infrastructure set up that made it easier for us, plus they could point out from real experience that it was an easy transition with many benefits. That helped a lot.

I took the lead on making the change for our team (is it true everywhere that on a digital design team, the verification engineers are the de-facto “tool guys” as well?). I studied up on how exactly mercurial works. I mean, I had the basic idea down since I’ve been toying with the fancy new revision control tools for a while now, but I didn’t really reach enlightenment until a few months ago when I read Steve Losh’s A Guide to Branching in Mercurial. I highly recommend it. My team now makes heavy use of named branches in Mercurial. Turns out we used branches a fair amount in Subversion and so the named branch workflow was a good fit for us. The fact that everyone had felt the pain of merging svn branches helped to motivate the switch to mercurial as well.

I used the hg convert extension to copy all of our history and a few important branches from subversion to mercurial. Besides the output of hg help convert, my old friend Rock’s Branches – Subversion Conversion to Mercurial, Part 2 helped me understand that process. Creating splicemaps to get merge information from subversion to mercurial was an important concept. I was confused on the syntax for a bit (convert could use some better error messages), but I figured it out eventually. The branchmaps were cool too, because we did have a badly named branch in subversion that we were able to give a better name in the conversion process.

It’s amazing what a good revision control tool does to you. With old clumsy revision control my mode of operation was just stashing changes to files, mainly so that I could hopefully go back to something that was working if needed. It was just a big undo button, in a way. I started noticing our very smart Linux kernel hacker software guys talking about linear history and clean cohesive changesets. Changesets where only one feature or bug was affected at at time. Changesets that showed a clear step-by-step process to completing a feature or fix. They scoffed at commits with messages like, “checkpoint: it compiles now.” At first I thought, “snobs,” but then I realized that mercurial provides tools that actually make it pretty easy to mess with your changes before pushing them to a public repository. And why not? When you are working in your own private local repository, why shouldn't you make sure everything looks neat and polished before going public with it? I started playing with the rebase and histedit mercurial extensions. Most of the software guys here swear by mercurial patch queues, but that just sounded archaic and complicated to me. I had some limited success with histedit, but recently I had another epiphany. Patch queues are actually pretty amazing. Again, Steve Losh helped with A Git User’s Guide to Mercurial Queues, but also just trying them out and seeing how nicely integrated with mercurial they are really helped a lot. I hadn’t realized that they were actually pretty darn easy to use, and so very flexible.

With Mercurial, revision control is no longer just a place to stash code, it’s a code editing tool all of it’s own.

Comments

Post a Comment

Popular posts from this blog

SystemVerilog Fork Disable "Gotchas"

This is a long post with a lot of SystemVerilog code. The purpose of this entry is to hopefully save you from beating your head against the wall trying to figure out some of the subtleties of SystemVerilog processes (basically, threads). Subtleties like these are commonly referred to in the industry as "Gotchas" which makes them sound so playful and fun, but they really aren't either. I encourage you to run these examples with your simulator (if you have access to one) so that a) you can see the results first hand and better internalize what's going on, and b) you can tell me in the comments if this code works fine for you and I'll know I should go complain to my simulator vendor. OK, I'll start with a warm-up that everyone who writes any Verilog or SystemVerilog at all should be aware of, tasks are static by default. If you do this: module top; task do_stuff ( int wait_time); #wait_time $display ( "waited %0d, then did stuff" , wa
Read more

'git revert' Is Not Equivalent To 'svn revert'

I just learned that if you have some changes in your working tree that you want to get rid of, you don't type 'git revert' like you might guess. No, that's what cvs, subversion, mercurial, and bazaar (to name a few) use revert to mean, but not git. With git, revert is used to undo actual commits. Thankfully, you can undo your revert with another 'git revert', I just learned. So let me repeat to be clear, if you have changes to your working files that you want to abandon, DO NOT do this: git revert HEAD That will undo your last commit. Do this instead: git reset --hard HEAD I'm glad I have that straightened out now. I'm wondering if /etc was really a good place for me to start out playing with git. UPDATE: Nearly two years later and I'm still getting comments on this. I'm glad I've been able to help people out this way. The discussion in the comments is good, and one thing I'd like to point out is that I now always use
Read more

Git Rebase Explained

Image
Introduction Rebase is a helpful git command that can be used to turn a branchy two-headed version history into an easy to follow linear one. A linear history is much easier for a human eye to follow and a human brain to understand. Rebase is a very safe command to use, despite some fear that people have about it. This post should explain how rebase works and clear up any misunderstandings about it. Rebase Basics The short summary of rebase is that it cuts commits out of the git history and reconnects them somewhere else. Let's say the common scenario comes up: you commit a change to the main branch of a repository, you then run  git fetch , and in come a couple changes that other people made on the main branch. If your commit is version 46f and the others that just came in on the fetch are versions ef9 and 4a2, your version history might look like this: The main branch now has two heads, 46f and 4a2. You can run  git rebase  to disconnect your commit from version d88 and connect i
Read more