Open vs Proprietary Rules

Frame the choice cleanly before weighing it. When a public regulation is turned into machine-readable logic, that encoding can be governed in broadly two ways. In the open model, the encoded rules are published and inspectable: anyone can read the logic, see the interpretive choices, check it against the source clause, test it, report errors, and often reuse it. The encoding is treated as shared public infrastructure - ideally stewarded by the regulator or a credible public body, versioned and dated in the open. In the proprietary model, the encoded rules live inside a vendor's product as private intellectual property: users can run checks and see results, but the logic itself - which rule was applied, how a judgement term was proxied, which exceptions were kept - is hidden, a trade secret they must take on trust.

The distinction is not about the software engine, which a company can legitimately build and sell either way; it is specifically about the encoded rules, the machine-readable version of public law. That is what makes the question pointed. A regulation is not a private asset. It was written by a public authority, it binds everyone, and citizens and professionals are entitled to know what it requires - indeed the prose is published precisely so it can be known. When the operative form of that rule becomes code, the open-versus-proprietary choice decides whether that same knowability carries over, or whether a layer of the law effectively goes private.

Most real situations sit somewhere on a spectrum rather than at a pole - a vendor might publish some rules and keep others closed, or an open rule set might be wrapped in proprietary tooling - but the underlying tension is real and worth seeing sharply. It is the tension between treating encoded public law as open infrastructure, like published statutes and open government data that everyone can build on, or as a private product, like ordinary commercial software. Which way a jurisdiction leans shapes who can trust the checks, who can catch errors, who bears lock-in, and who ultimately controls the operative form of the law. The rest of the lesson argues that for public regulation the transparency, trust and public-good considerations weigh heavily toward open - while being fair about what the proprietary model offers and honest that, either way, the published law remains the authoritative rule.

The strongest argument for open rules-as-code is that it directly answers the problems this module has been building. Take transparency first. Everything that can go wrong with an encoding - a mis-read clause, a badly chosen proxy, a dropped exception, a stale version - is a problem you can only find and fix if you can see the rule. Open encoding makes the interpretive choices visible: a practitioner, a rival vendor, an academic or the authority itself can read the logic, compare it to the source clause, and catch an error. That is a public audit loop - published rule, open inspection, errors found and challenged, correction and re-publication - and it is the same mechanism that makes open-source software and open data trustworthy: many eyes, in the open, over time. A closed rule has no such loop; an error can persist unseen because no one outside is allowed to look.

Trust follows from transparency. In an open model, you trust the encoded rule because you (or someone acting for the community) can verify it against the law; trust rests on inspectability. In a proprietary model, you trust the rule because you trust the vendor's brand and claims; trust rests on reputation and secrecy, which is a weaker foundation for something as consequential as the operative form of public law. When a design's fate turns on encoded logic, being able to see and contest that logic is close to a matter of due process.

Then the public-good arguments. A public regulation encoded once, openly, can be shared by everyone who needs it - regulators, professionals, tool-builders, researchers - instead of being re-encoded, privately and inconsistently, inside every competing product, which is wasteful and produces divergent readings of the same law. Open encoding avoids lock-in, where a profession or even an authority becomes dependent on one vendor's proprietary rule set. It lowers the barrier for small practices and the public to check designs, rather than gating access to the operative law behind a licence fee. And it keeps the encoded law as a commons, maintained in the light, aligned with the principle that law should be knowable. These are the same reasons societies publish statutes freely and increasingly release government data as open data. For encoded public regulation, the logic is even stronger, because the code is not just information about the law - it is, in operation, the form of the law being applied.

An honest lesson gives the proprietary side its due, because it is not merely greed and it does offer real things. Building and maintaining good checking tools and current rule sets across many jurisdictions is expensive, skilled, unglamorous work, and commercial vendors fund it. A proprietary model can pay for sustained maintenance, responsive support, polished usability, integration with design software, and continuous investment that a thinly-funded open project may struggle to match. If a vendor's revenue depends on keeping rules current and the tool working, there is a real incentive to do the maintenance this module has shown to be so demanding. Intellectual-property protection is also the ordinary way commercial software sustains itself, and there is nothing inherently wrong with selling a checking engine or a service built around encoded rules.

But weigh the costs squarely, especially for the encoded rules themselves. Opacity is the central one: a proprietary rule set is a black box, so its interpretive choices cannot be audited, its errors are hard to detect and harder to contest, and the transparency and trust arguments simply do not hold - you are asked to trust logic you cannot see, applied to a public rule. Lock-in is the second: dependence on one vendor's encoding gives that vendor outsized influence over how the law is operationally read, and makes switching or independent verification hard. Duplication is a third: every vendor separately re-encodes the same public rules, wastefully and with divergent interpretations, so the same byelaw is read differently by different products. And there is a deeper unease: a private company's secret interpretation becoming the de facto operative form of a public law is a governance problem in itself, regardless of the company's competence or good faith.

The reconciling position is not 'all software must be free'. It is to separate the layers. The engine - the checking software, the interface, the integrations, the support - can legitimately be a commercial product, open or proprietary, competed on and paid for. The encoded rules - the machine-readable version of public law - are the layer where the transparency, trust and public-good arguments bite hardest, and there the weight falls toward open: ideally the authority publishes authoritative, versioned encodings of its own rules as open infrastructure, and vendors compete on the quality of the tools built around that shared, inspectable rule set. That gives the funding and usability benefits of a market while keeping the operative form of the law visible and accountable. And whichever way a jurisdiction actually lands, the fixed point holds: the authoritative rule is the published law, not any encoding of it, open or closed.

Pulling the module together, the governance question of the encoded rule set turns out to be where its earlier themes converge. Interpretation must be visible to be trusted; currency must be trackable to be verified; accountability must be legible to be held - and all three are far easier when the rules are open than when they are locked away. So the direction this lesson argues for is open, accountable encoded regulation, treated as public infrastructure, with a realistic sense of what that takes.

It takes stewardship. Open does not mean unowned or unmaintained - the failure mode of a naive open model is an abandoned, stale rule set no one is responsible for, which is its own kind of dangerous. The strongest arrangement is the regulator or a credible public body owning the authoritative encoding of its own current rules, publishing them openly with versions and dates, running the reconciliation process the currency lesson described, and inviting the public audit loop the trust argument relies on. That combines the authority of the rule-maker, the transparency of open publication, and a named steward accountable for maintenance. Around that shared, open rule set, a healthy market of tools - some open, some proprietary - can compete on usability, integration and service without privatising the law itself.

In the Indian context this points somewhere concrete. The quantitative development-control rules that dominate plan-scrutiny are exactly the checkable kind, approval-digitisation is real and advancing, and the natural stewards of open, versioned encodings are the states and urban local bodies that make and interpret the byelaws - publishing the operative form of their own rules as open infrastructure rather than leaving thousands of jurisdictions to be encoded, opaquely and inconsistently, inside competing private tools. That is a governance and public-infrastructure choice, and it is being actively shaped now. Whichever way it goes, the discipline this whole module teaches holds: an encoded rule is an interpretation that must be visible, a snapshot that must be kept current, and an instrument whose failures must be answerable - and the authoritative rule is always the published law, interpreted and applied by the accountable professional of record and the approving authority. Studio Matrx, free and not-for-profit, argues for open rules-as-code as the arrangement most consistent with the old principle that the law should be knowable by everyone it binds - while deferring every binding result to the professional, the authority and the governing code, byelaw and standard.