Governance is emerging as one of the key challenges facing DAOs, and - as the space becomes more developed - crypto communities generally. Strong group decision-making will be critical to resolving challenges from the existential - such as hard forks - to the operational - such as treasury allocations or fair developer compensation.
Legitimacy, fairness, participation, consensus - for many software engineers, such concepts are frustratingly nebulous compared to the determinacy of code, which works or it does not (kind of!)
This blog is an attempt to reframe blockchain governance in a developer-friendly frame.
Every group decision follows some process. That decision-making protocol can be viewed as an executable - in particular, a governance executable - similar to software. But rather than simply silicon, we are running this executable on the data processing infrastructure of Web3 communities. Part of that infrastructure is the wetware of individual human minds, and some is the silicon hardware that runs smart contracts.
Both wetware and hardware run very quickly. However, the communication networks between them - although instantaneous - run very slowly due to protocol translation delays.
As any programmer knows, the operation of a piece of software passes through a number of different stages. While the execution of software (often) seems almost instantaneous, when different stages run on different platforms, with slow networks connecting them, then execution can be quite slow.
This is the situation with governance. A decision-making process is in fact an algorithmic process, but one with distinct stages, and executing those stages properly, in the correct order necessary for optimal results, takes time. What those stages are depend on the decision being made, but generally they fall into categories such as ideation, nomination, deliberation, evaluation, aggregation and ratification. Some stages - such as deliberation - are slow. Others - such as aggregation - are fast. Moreover, there are specific qualities of process execution that lead to good or bad results - such as transparency, truthfulness, specificity, inclusion, fairness, unity and more. These terms can be well defined.
The Ethelo Engine allows different decision stages to be connected together, like code blocks, into a process that results in a broadly supported decision outcome. In this way, a decision protocol/governance executable can be run in a manner similar to a multi-stage smart contract. Such executable protocols provide organizations the ability to obtain clear direction from members on complex decisions, by crowdsourcing the tradeoffs and analysis needed to arrive at fair, sound outcomes.
Software development methodology can be translated to the problem of governance. The key is to view each group decision as a staged algorithm that must run on this multi-platform network of human minds and computer hardware. Setting out those stages clearly at the beginning, performing them accurately and iterating often are keys to success. The last - evolutionary iteration - is where DAOs running on smart contracts have the potential to move quickly ahead of the rest of the world when it comes to governance.