It’s been a couple of days since I’ve updated, for a couple of reasons: (a) I’m actually spending some time away from a computer, and (b) my ‘net connection from home continues to suck (but also continues to be free).
Let me describe the trouble I had at work on Friday. I’m going to get technical here for just a bit; take a deep breath and read on.
In order to better allow for future growth, three weeks ago we refactored our code base, which is a fancy way of saying “moved stuff around”. As with real life, if you change something that is relied upon — be it a process, theory or expectation — you’re gonna have some talkin’ to do. In this case, the refactoring broke the automated C++/java/Obj-C build and assembly system I implemented back in January. Because we had just finished a release, until a few days ago we hadn’t been doing regular builds, so this hadn’t been a problem.
In addition to shuffling stuff around, we were simultaneously attempting to integrate the merge of two independent-yet-similar-in-goal cross-platform libraries. Fixing the build and assembly system was easy enough. The trick was that, after all was said and done, things no longer worked. Which meant the problem either lied in our refactoring (unlikely), or in the newly merged libraries. The implementation of these libraries was fundamental: greater than 90% of our work depends on them.
A closer look at the refactored code revealed a nightmare. Turns out that when we refactored, we had done so on an old code base! Entire files were missing! So we re-refactored. The second time around, this process was much faster, taking a little over an hour instead of a day. Now we have to figure out what was developed on the old code base and integrate it back into the re-refactored code.
So yeah. Work is tricky. Thankfully tricky work like this is always accompanied by that which is considerably less so. Such as this conversion process: