4 ms·

Sorry, having a hard time making sense out of this. If you understand what this guy is talking about can you provide a coherent summary of the video please?

oddity 7y ago
This is my best guess interpretation. I might have misunderstood some parts, so I would love it if someone else could correct me. Imagine a distributed system where nodes in the computation compute some result by communicating intermediate results between each other, and can withstand some number of nodes failing. This is possible because, with careful design of the algorithm and edges between nodes, each node has enough self-sufficiency to detect when its neighbors are misbehaving. Dave Ackley starts off with the following observations: 1. It becomes harder to maintain the deterministic properties we love as we scale the complexity of the nodes. 2. A node's random access to memory/state becomes less reliable the more state there is because the complexity of the node must also scale. 3. 1 and 2 make it harder for complex nodes to guarantee correct results. So, he proposes the following: what if we scale nodes way down to the point where their messages are very small (on the order of bits). This moves the problems that might otherwise be observed within the nodes to the network structure between nodes. At first, this might not seem like this offers much; however, this allows us to reason about resiliency at a much finer granularity. Ulam is a programming language for such a system, running on a machine model that resembles a cellular automata where the cells are slightly more intelligent. He illustrates this via a line that reconstructs itself as he manually disrupts them, but a more familiar and practical (though much more complex) hypothetical use case might be a network of many adder-circuits that can dynamically tolerate some number of random bit flips. If one were to program for such a system, you could think of a program as a living organism that repaired itself statement-by-statement even on faulty hardware. Edit: There is a more in-depth article available at https://www.mitpressjournals.org/doi/pdf/10.1162/ARTL_a_00212 https://www.mitpressjournals.org/doi/pdf/10.1162/ARTL_a_0021... I haven't read it yet, but I will.
- programmer_dude 7y ago
  Thanks, this is much easier to understand. Much appreciated!

oddity 7y ago

This is my best guess interpretation. I might have misunderstood some parts, so I would love it if someone else could correct me. Imagine a distributed system where nodes in the computation compute some result by communicating intermediate results between each other, and can withstand some number of nodes failing. This is possible because, with careful design of the algorithm and edges between nodes, each node has enough self-sufficiency to detect when its neighbors are misbehaving. Dave Ackley starts off with the following observations: 1. It becomes harder to maintain the deterministic properties we love as we scale the complexity of the nodes. 2. A node's random access to memory/state becomes less reliable the more state there is because the complexity of the node must also scale. 3. 1 and 2 make it harder for complex nodes to guarantee correct results. So, he proposes the following: what if we scale nodes way down to the point where their messages are very small (on the order of bits). This moves the problems that might otherwise be observed within the nodes to the network structure between nodes. At first, this might not seem like this offers much; however, this allows us to reason about resiliency at a much finer granularity. Ulam is a programming language for such a system, running on a machine model that resembles a cellular automata where the cells are slightly more intelligent. He illustrates this via a line that reconstructs itself as he manually disrupts them, but a more familiar and practical (though much more complex) hypothetical use case might be a network of many adder-circuits that can dynamically tolerate some number of random bit flips. If one were to program for such a system, you could think of a program as a living organism that repaired itself statement-by-statement even on faulty hardware. Edit: There is a more in-depth article available at https://www.mitpressjournals.org/doi/pdf/10.1162/ARTL_a_00212 https://www.mitpressjournals.org/doi/pdf/10.1162/ARTL_a_0021... I haven't read it yet, but I will.

programmer_dude 7y ago
Thanks, this is much easier to understand. Much appreciated!