
Robust-first programming in ULAM (2015) [video] - akkartik
https://youtube.com/watch?v=I4flQ8XdvJM
======
programmer_dude
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
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_0021...](https://www.mitpressjournals.org/doi/pdf/10.1162/ARTL_a_00212)
I haven't read it yet, but I will.

~~~
programmer_dude
Thanks, this is much easier to understand. Much appreciated!

