Computing technology is still in its infancy with respect to durability, reusability and correctness of code, as evidenced by the fact that developers have to deal with system issues constantly in application code. We are always writing almost the same code over and over because the new code is running on a different language or platform, takes advantage of new system features, or needs different dependencies. We don’t have a space to construct abstracted data and operations where we are free from thinking about the machine boundaries, memory management and other concerns that detract from the purity of the logic. Therefore most of what we write is within the space bound by those limits.
Engineering today is therefore an art of tying together the abstract perfection of pure logic with the finesse of manipulating actual machines. That art – working around limitations – is essentially what’s difficult about the art. It’s hard mainly because the technology is immature.
To be highly effective, we have to stay focused on what’s coming and meanwhile work with what we have. That’s the concept of “megaworkarounds” – the collection of work patterns and techniques used to effectively work around the limitations of the state of technology. We need to be aware when we are doing a megaworkaround and why, and that’s what this article covers. It’s not about “best practices” (as if that characterizes some kind of end state) but it’s rather about ways to do things solidly despite being amidst chaos.