My view of this is obviously colored by having worked as a developer, but I see the legal code as being analogous to writing source code. They both establish rules by which processes run. It&#x27;s almost like source code that&#x27;s being run by millions of humans rather than machines. And similarly when you write source code, adding a couple of if clauses or function calls to verify data doesn&#x27;t really impose a performance penalty or make the code unreadable. But, over time, if you continue to litter your code with these small conditionals, it becomes harder and harder to reason about and the combined weight of those little changes can introduce some performance penalty.<p>This is often referred to as technical debt and requires that the programmer delve into all of the various conditions that have been added and attempt to understand and simplify them such that the overall behavior is more or less unchanged.<p>I see this article as not a call for reduced regulation but, instead, as a call to address our legislative debt. We need our representatives to stop simply piling on new regulations and, instead, distill everything we currently have into something that makes compliance easier without losing the spirit of the legislation. This won&#x27;t be easy for many reasons, not least among them that laws don&#x27;t have refactoring tools and unit tests to ensure that the simplified version maintains the existing behavior and our combative, partisan system means that refactoring our laws would introduce opportunities for partisan politics and debating over the existing behavior, but that doesn&#x27;t mean we shouldn&#x27;t try. Because the alternative is all the bad things listed in the article. And from my experience with technical debt, the longer it&#x27;s allowed to accumulate, the harder it is to fix and the less likely people are to even attempt a fix.