If a transaction leaves your hands, the real test isn’t how fast your local machine is—it’s whether that message can reach the nodes that need it in an organized way. Users can’t see this journey, but it affects why consensus is slow and why duplicate processing occurs.
Think of the network as a city. The most brutal approach is for every intersection to copy the same notification and send it to all neighboring intersections. The notification will spread, but at the cost of massive duplication. Kadcast’s idea isn’t to have every node call out the message again and again; instead, it uses Kademlia’s distance organization and XOR distance to place the message into a structured forwarding relationship, reducing indiscriminate flooding.
What matters here isn’t “how close Dusk is to completion,” but that you finally have a more accurate question: where is the cost of message coverage? Execution time only answers how quickly nodes process things. The propagation path must answer how the message is delivered to other nodes. If you don’t account for both ledgers, you can’t treat a partial result as overall performance.
Of course, the Kadcast in the whitepaper is a mechanism design, not a benchmark report for the current mainnet. Node scale, network fluctuations, and the actual routes—all of these can change the final outcome. Looking at @Dusk , I’ll first map out this path, then determine whether consensus is being slowed down by redundant rebroadcasting. $DUSK is a network-native token and can’t be used as evidence for this chart; and the technical discussion in #dusk should also start with how messages actually get delivered.
From the perspective of normal usage, a confirmation message doesn’t appear out of thin air—it goes through propagation, reception, and duplicate processing. We can’t simply draw conclusions about the mainnet out of a whitepaper, but we can start by asking the right questions: if a message-coverage method for an execution engine is still inefficient, which layer will ultimately hold back the user-visible experience? Incorporating the path into performance is exactly what makes this mechanism worth observing.
Look at the path first, then the numbers—never the other way around. Don’t just watch execution speed.
Think of the network as a city. The most brutal approach is for every intersection to copy the same notification and send it to all neighboring intersections. The notification will spread, but at the cost of massive duplication. Kadcast’s idea isn’t to have every node call out the message again and again; instead, it uses Kademlia’s distance organization and XOR distance to place the message into a structured forwarding relationship, reducing indiscriminate flooding.
What matters here isn’t “how close Dusk is to completion,” but that you finally have a more accurate question: where is the cost of message coverage? Execution time only answers how quickly nodes process things. The propagation path must answer how the message is delivered to other nodes. If you don’t account for both ledgers, you can’t treat a partial result as overall performance.
Of course, the Kadcast in the whitepaper is a mechanism design, not a benchmark report for the current mainnet. Node scale, network fluctuations, and the actual routes—all of these can change the final outcome. Looking at @Dusk , I’ll first map out this path, then determine whether consensus is being slowed down by redundant rebroadcasting. $DUSK is a network-native token and can’t be used as evidence for this chart; and the technical discussion in #dusk should also start with how messages actually get delivered.
From the perspective of normal usage, a confirmation message doesn’t appear out of thin air—it goes through propagation, reception, and duplicate processing. We can’t simply draw conclusions about the mainnet out of a whitepaper, but we can start by asking the right questions: if a message-coverage method for an execution engine is still inefficient, which layer will ultimately hold back the user-visible experience? Incorporating the path into performance is exactly what makes this mechanism worth observing.
Look at the path first, then the numbers—never the other way around. Don’t just watch execution speed.