Do I Really Need to Check Invariants at the End of My Methods?

If you're looking at not breaking invariants dynamically, that's a solid approach. However, if your logic leading up to invariants breaks often, you could run into trouble without those checks. Other developers also find having these invariants makes the code easier to understand for future changes, drastically reducing misunderstandings about what the code is supposed to do.

There are frameworks out there, like OpenAPI and Django Validators, that handle some validity checks for you, although not exactly at the end of every method. They trigger checks based on significant events like database transactions instead. Personally, I don’t code invariant checks at method ends—I rely on the framework to enforce these rules when pivotal changes happen, which can complicate debugging since multiple methods are usually involved.

It really depends on what your application is doing. If a minor issue can simply prompt a retry from the user, maybe you can forgo heavy checks. But if your application relies heavily on maintaining strict invariants, skipping checks could lead to unseen issues down the line. The real-world behavior of your code can be unpredictable; missing a check at a certain point might lead to serious problems later.

I’m not too sold on the idea of needing to check invariants. In my view, just using Immutable Objects along with solid unit testing seems to cover the bases just fine. Plus, adding an invariant checking method could make things less scalable, since it’s another piece that needs maintenance. It feels like unnecessary overhead to me, but others might disagree.

Just trusting your logic isn't enough. The book seems to stress that you can't rely solely on unit tests; they won’t catch every strange input or edge case. Runtime invariant checks can help ensure your code handles real conditions appropriately, and having those explicit limits in place can make future code modifications clearer.