The biggest software project I have ever worked on, and hopefully ever will work on, was Gecko. I was not one of its original architects, so my work on Gecko was initially very tightly constrained by design decisions made by others. Over the years some of those decisions were rescinded, and some of the new decisions were mine, but I always felt frustrated at being locked into designs that I didn’t choose and (with the benefit of hindsight, at least) would not have chosen. “Wouldn’t it be great”, I often thought, “to build something entirely new from scratch, hopefully getting things right, or at least having no-one other than myself to blame for my mistakes!” I guess a lot of programmers feel this, and that’s why we see more project duplication than the world really needs.
I was lucky enough at Mozilla to work on a project that gave me a bit of an outlet for this — rr. I didn’t actually do much coding in rr at the beginning — Albert Noll, Nimrod Partush and Chris Jones got it underway — but I did participate in the design decisions.
Over the last two years Kyle Huey and I have been working on a new project which is broader in scope and more complicated than rr. The two of us have designed everything (with some feedback from some wonderful people, who know who they are) and implemented everything. We’ve been able to make our design choices quite freely — still constrained by external realities (e.g. the vagaries of the x86 instruction set), but not by legacy code. It has been exhilarating.
However, with freedom comes responsibility. My decision-making has constantly been haunted by the fear of being “That Person” — the one whom, years from now, developers will curse as they work around and within That Person’s mistakes. I’ve also come to realize that being unencumbered by legacy design decisions can make design more difficult because the space is so unconstrained. This is exacerbated by the kind of project we’re undertaking: it’s a first-of-a-kind, so there aren’t patterns to follow, and our system has novel, powerful and flexible technical capabilities, so we can dream up all sorts of features and implement them in different ways. It’s scary. We have to accept that mistakes will be made and just hope that none of them are crippling. After all, if developers are cursing our design decisions years from now, that means we succeeded!
One of our biggest challenges is constantly trying to strike the right balance between forward planning and expediency. It’s always tempting to respond to uncertainty by planning for all possibilities, by building abstractions that make it easier to change decisions later. Another temptation is to obsessively study issues to reduce the uncertainty. All that represents delay for our minimum viable product, and therefore must be minimized. My general approach here is to try to think about the future, but not code for it; to tell stories about how we would handle possible future scenarios, but not invest in them yet.
I think we’re doing OK. Being nearly two years in is long enough to have regrets, and we don’t have many. It will be very interesting, and humbling, to review our scorecard over the longer term.