A co worker thinks enforcing basic code quality standards are worthy insights.

Here's an example. I currently work on a large, legacy codebase -- an interactive C++ application -- that uses old patterns for callbacks among components and user code. There are C functions to register a callback handler, where you pass in a function pointer and a `void *`. When issuing a callback, the application iterates through the list of function pointers, and calls them while passing through the `void *` that was passed when registering the callback. The callback interfaces themselves are rather huge. They pass an enum element to tell you which event took place, and use a variadic function signature to pass a varying number of arguments depending upon the callback event. Obviously, the typing discipline here is very loose. I wrote some code to improve upon the situation for some particular callback interface. I created a C++ class with virtual functions for each of the callback events. My class provides a `static` function that implements a `switch` over the callback enum code, then extract the correct argument types from the variadic `VA_LIST`. Finally, they call the correct virtual function. The upshot is that clients don't have to deal with any of that variadic/callback/`void *` mess anymore. All they have to do is derive from my class, and override the virtual functions of interest. It's a much cleaner way to interact with those callbacks. Well... the `static` function I mentioned is pretty large, because it needs to convert the arguments for about 50 callback events before calling the correct virtual function. But the code is all simple, repetitive, easy to understand, and has an extremely low maintenance burden for new callback events of just adding a new switch case, a new virtual function, and some argument deserialization code. It's all implemented in one function that's a few hundred lines long, and I don't care to bother looking for an alternative solution just for the sake of it, since it works, it's easy, it does what it needs to do, and it's a massive improvement over the interface that I'm wrapping.