Inside you will find my proposal for a protocol-first code applicable to algorithmic smart entities.
The inspiration comes from a game I have been playing recently called Zachtronics | EXAPUNKS and the type of robots you find in Factorio (Logistic, Construction and Worker).
I took the idea of an EXecution Agent and formulated it under the light of my last post.
I like this minimalistic implementation of swarm intelligence (Wikipedia reference), à la Touring Machine. It feels like an “universal implementation” given the possibility of infinite regimes, modes and signals.
If it’s universal, it would be possible to build any protocol on top. For example, although entities are not aware of other specific entities, I can see how you could build an “identity protocol” on top that would allow for (specific)-entity-to-(specific)-entity relationships.
The distinction between regimes and modes is also interesting… but I’m not sure I understand it. Maybe “regime” is related to (internal?) resource managament (energy) and “mode” is related to the function in the system.
A very silly minor detail that I’m not sure about: you could change the local signal to allow for N steps instead of just one. It’s a bit more complex and technically not needed, but it doesn’t violate the “anonymity between entities” principle.
You are welcome. Given your background I knew we’d have interesting points from your commentary.
You are right, I went for a very universal abstract approach, this is closer to a writeup than to a technical specification. Although when I think about the lines of protocol code necessary to describe very basic protocols, this is closer to low level assembly than a high-level language.
Since I felt like I had some good definitions to work with, I tried to reason a skeleton language, that can be used as pseudo lang to draft protocol implementations (software) that drive protopunks (hardware), which are defined to be as generic as possible.
The difference between a mode and a regime is that,
A mode of activity, decides the outcome. Certain modes of behaviors are better in certain situations than others.
A regime of activity, decides how efficient is your activity at achieving the outcome and how long you can last doing so.
A mode of activity will have a bare minimum regime, and possibly if you opt for higher regimes you could improve your outcome. Sometime, a mode has a cap where even a higher regime doesn’t really change much.
All in all, it depends on the situation.
Speaking about swarm, the first impression I had from a friend was, this could apply to autonomous drones.
When it comes to signals, I thought about how we operate.
The idea behind local is to model conversations which a known mode of reasoning solutions. Now if I try to specify the number of steps, well that puts an assumption on the smart network, maybe what I am looking for is not N steps away, as we assume that things are dynamics and entities can be elsewhere in which case they detach and attach to various networks constantly depending on their need. But you reinforced the idea that there should be something like, targeted signaling.
Like, I don’t know where this protopunk is but given my interactions, I need it to be aware of something. Now I don’t know if it is unique enough that it should be a feature, or we can make it happen using global signaling. Like if two protopunks setup a set code, then if I signal it globally, then no protopunk should be able to consume it except the one concerned, otherwise the signal keeps bouncing through the network until it is consumed or maybe have a system to manage unconsumed signals, I mean we have freedom. Maybe too much.
Sorry, I’ve been mostly offline last couple of days
Speaking about swarm, the first impression I had from a friend was, this could apply to autonomous drones.
Theoretically, sure, drones are one of the most common examples for swarms. But IMHO this type of minimalistic implementations are not practical. Similar to trying to build a computer using a Turing Machine architecture. Without being able to index other nodes it would be very hard to program complex things.
Like if two protopunks setup a set code, then if I signal it globally, then no protopunk should be able to consume it except the one concerned
Yeah, that’s how I imagine the “identity protocol”, a handshake to initate the “connection” adn global messages to communicate.
This make me think that I should be looking at something here. I will consider this point further.
For now, I am gathering questions from this initial writeup and comments that could guide further development.
How would a protopunk handle an unknown signal? Related to dealing with the unknown and the process of learning.
Given that our aim here, is emergent programming, not deterministic, we want to design for an open world not a closed one, what the properties that these protopunks should have vs what do they have now (as presented in the writeup)?
The only dynamic thing about protopunks is the fact that they can roam space and as a consequence be part of various networks through that mobility, given that networks form by proximity. Everything else is static in sense, we need a way to evolve signaling (make them learn new signals and respond to their codes), emerge new modes of behavior (!!) and possibly optimize their regimes (?!)
I would suggest taking a look at FORTH (wikipedia), a stack based language, it’s the most flexible-at-runtime language I know [EDIT: I mean a language used in real life applications, as these NASA examples]
A couple of introductory resources I would recommend:
It may be hard to fully grasp for a while, but Forth’s only syntax is the whitespace between tokens of input.
Note that I don’t mean that I think you should use Forth. But its minimalistic design fits very well with your draft and it could be a source of inspiration.