I mentioned, in the course of kicking the blog back to life, that over the past month or so I was doing some freelance work in an effort to fill in some of the income gap associated with paternity leave. And also, frankly, to give myself some intensive practice with nuts-and-bolts coding again, as that is something that is in short supply at my regular gig. (For that reason alone, you would think my current employer would be happy about me picking up some work on the side in an effort to keep my skills sharp. Alas, I think it would probably be frowned upon, so I’ve been keeping it to myself and thankful once again that these posts are usually light on the personally identifying info.) This past weekend was the culmination of a big chunk of that work, evocative of the old truism that the best thing about hitting yourself in the head with a hammer repeatedly is that it feels so good when you finally stop.
Writing new code for my old company’s main product was time-consuming, primarily because there were so many things they wanted tweaked or modified or enhanced (and secondarily because I had to re-orient myself to the inner workings of the thing after having been away for six years or so). But I budgeted my time (for once!) and chipped away at it day after day for weeks until every requirement had been met. The plan was for me to finish my side of things by last Monday, and my former colleagues to test all last week, so that the finalized changes could all be released to the client today. The testing then became time-consuming for entirely different reasons, because at that point there’s back and forth involved, with someone alerting me to a glitch and me looking into it and communicating back that it’s fixed and can be re-tested (or that what looked like a glitch was really user error) and so on. All of the communication was done via e-mail, and sometimes there would be a necessary delay as I had to wait until I got home from my day job before I could start testing anything. The testing got more intense as the week went along (and the deadline got closer) and I had a sizable to-do list by Friday, but I stayed up late Friday night dealing with everything.
Everything that had been identified to that point, that is, which really wasn’t technically everything. And once things spilled over into the weekend, they got significantly hairier. I knew what I was getting into with this project, and nothing happened that wasn’t totally typical for the development cycle, with the major exception that everything was so loosely structured. I assumed I would be hearing more from my former colleagues on Saturday, but I didn’t know when or how much, so when the first e-mails started buzzing my inbox around 4 in the afternoon, I wasn’t sure whether to jump on the issue raised immediately, or to wait until multiple messages arrived so that I could sit down for a concentrated, presumably more efficient session of work. I split the difference, answering e-mails immediately when the solution simply involved clarifying a misunderstanding, and holding off on actual troubleshooting and code revision until later, which ended up being a de facto necessity once it got to be time for the kids’ dinners and baths and bedtimes and whatnot. But eventually I was back at the computer and once again stayed up late to handle the work. The difference Saturday night, though, was that there was a lot of back-and-forth e-mailing accompanying all of my adjustments and modifications ... until at one point there wasn’t. I’d been dealing mainly with three of my former colleagues and there was an open issue which I couldn’t address without one of them in particular, and he was apparently not online. It was past midnight, and while no one had officially sent a “let’s call it a night” message, I decided to do just that.
Because, of course, on Saturday morning my wife and I had been passing the kids back and forth in various combinations and also running out on shopping errands in order to get ready for the little girl’s birthday party on Sunday. Plus there was the customary amount of laundry and housecleaning to be done over the weekend as well. So it was a long day on the heels of a long night, with the uncertain expectation of freelancing-related e-mails hanging over my head basically every waking moment. At least these days I have a smartphone that notifies me when I get a new e-mail, without which I would have been an anxious wreck (well, moreso). And Sunday proved more of the same, with the morning given over to continuing to get ready for our guests (fortunately in our family we tend to keep 2nd birthday parties small, so the headcount was limited to the local grandparents, uncle and aunt), the early part of the afternoon for wrapping the presents and icing the cake (which I had mixed and thrown in the oven the night before in between bug fixes), the latter part of the afternoon for the party and dinner, and then the bulk of the evening and beyond devoted to responding to the final round of e-mails as the immutable deadline loomed closer and closer. Hence the sugar and caffeine inhalation I copped to at the top of this post.
The good thing about last night’s efforts was that they did reach an unmistakable ending point, as opposed to Saturday’s ambiguous trailing off. I got a message that the testing was complete and that I should send over all of the notes and instructions for replicating the changes on the live site, which they would take care of internally. So I did all that and then went to bed, although I was unable to shake a certain amount of paranoia that I would miss a desperate emergency e-mail in the middle of the night, or that I would get an equally desperate request for help this morning when there was nothing I could do about it mid-commute. But it’s past noon now and I haven’t heard a thing, which either means the final deployment went smoothly or that it flamed out spectacularly and they just aborted the effort, restored a backup version of the site, and I will hear from them once they’ve determined how they can best limit their liability for paying my invoice.
But assuming it’s the former then that really should be the end of the project, barring any issues that didn’t crop up in testing but come to light with heavier customer-base usage. Of course, when my former colleagues reached out to me they had two projects in mind, one massive and deadline sensitive and the other much more modest and with less of an associated time crunch. I said yes to doing both, and so with the former finished I can move on to the theoretically easier project, and at least I’ll know how the endgame is likely to look this time around. And then after that, I honestly have no idea if my former colleagues have more work they would want done, or if after this experience they would want me to do it, or if I would take on the work if it were offered. Probably so, to the last part (assuming I could take a little break first) because that’s always the way these things go, grueling when you’re eyeball deep in them and then not seeming so bad after the fact when it’s time to decide whether or not to do it again.