Creating a Linked Server in Amazon RDS for SQL Server: A Step-by-Step Guide (2024-01-29)

Creating vs. Maintaining

If your job as a developer or DBA has been like mine, it's a constant stream of requests to change something, often without enough information and short deadlines that create a bit of stress. There's always more work to be done, and while it might be a great job, you're often trying to finish something quickly enough to get to the next thing.

In this mode, how often do you think about creating (or modifying) the thing you're working on for today vs maintaining it for tomorrow. In other words, do you consider how easily your work can be understood, is documented, is designed to allow for flexibility, and can be enhanced without many (any?) side effects, or anything else.

In other words, is it maintainable?

We often build things to solve a problem and we can be very creative. We design a solution that works well, solves a problem, and may work very efficiently. However, I know I often haven't thought about future maintenance. I haven't considered how difficult it may be to understand the context around what I put together by anyone else. Sometimes I've built things that things that were very clever, but weren't easily understood by my team or able to easily adapt to new requirements when those arise.

Often I've been looking at the problem from only a "it's this tree that's important" perspective, and forgetting that my particular thing is part of a wider system (a forest). I hadn't been considering future maintenance, which often led someone in the future (often a future-me) to tear it down and rebuild something new.

That's technical debt.

When some structure isn't maintainable, it's debt. It's a burden for the team in the future. Designing things quickly and building them within a deadline, while making them maintainable requires some knowledge, experience, and also discipline to work with the patterns, and avoiding the anti-patterns, that make code difficult. The same thing applies to managing systems. Custom jobs on every server and separate configurations make life hard. At the same time, a one-size-for-everyone approach also isn't maintainable. We need a balance of well-written solutions that solve our problems, but are easily maintainable.

Part of becoming a better engineer or admin is learning how to build maintainable things that others will continue to use for a long time, not because they have to, but because they want to because the code works well.

Steve Jones - SSC Editor

Join the debate, and respond to today's editorial on the forums