https://catern.com/change_code.html

Prefer to change the code rather than write a workaround

I can't count how many times I've heard programmers talking about
writing some new piece of code to work around the behavior of some
other code which they don't want to change. You are a programmer -
you are allowed to change code! In fact, it's your job! Just change
the code to do what you want! Fix the bug! Change the behavior! Add
the feature!

  * Log message that's noisy and useless? Delete the logging code!
  * API that doesn't expose what you need? Add a new parameter!
  * Library that does something horrible that all your software
    depends on? Turn off the horrible behavior and remove your
    dependency on it!
  * Open source software that's doing bad stuff? Patch it locally and
    send the patch upstream!

I'm talking about situations where you know how to solve your
problem, but you've chosen to implement that solution in some
additional layer of code on top, rather than changing the original
problematic code. As has been expressed many times before, code is a
liability; the more code you have, the worse off you are. So just
change the original problematic code instead!

There are some basic technical excuses one might give for why you
aren't able to change the code. For example:

  * But I'm not allowed to touch this code!
  * But I don't know how to change it!
  * But I don't know where the source code is!
  * But I can't build this software!
  * But I can't run the tests!
  * But I can't use a modified version of this software!

Some people work in an environment where these excuses are valid, and
they might find it hard to believe, but there are many environments
where these excuses don't apply. Try to move from the former to the
latter: don't use software where these things are an issue, make
software open-source rather than closed-source, and quit your job in
favor of work that has good developer tools.

There are also some social/political excuses. For example:

  * But changing the code means we have to talk to the people who own
    this code!

    So what? They'll probably be happy that you're looking at their
    code and trying to improve it! If they aren't happy, then maybe
    what you're trying to do is evil anyway, and you should be
    thankful that they're stopping you. If what you're doing is good,
    but they're still not happy, then fork and upstream later.
  * But changing things will impact other users!

    If what you are trying to do is good for them, they will be
    happy, and you should embrace the costs and benefits of
    coordinating with them. If what you are trying to do is bad for
    them, then that's a sign that you shouldn't be doing it. If you
    choose to do so anyway, you can surely figure out a way that they
    don't have to use your changed version.
  * But we haven't budgeted time to do it the right way!

    Then you never will budget time to do it the right way. Do it the
    right way now or you will suffer forever.
  * But this is supposed to be a quick experiment!

    You can perfectly well do a quick experiment by modifying the
    original code; indeed, it should be quicker to do it that way.

Fear not! Just change the code!