Haven't heard of Drogulus before, sounds interesting.

Anything that implements a Kademlia-like decentralized key-value datastore (basically, a DHT) gets my curiosity. Kademlia is a system/protocol how to implement a DHT and how to perform searches on it. The idea is that all network nodes are identified by a (traditionally, 160bit I think) hash. If you want to implement a P2P filesharing network based on Kademlia (like Gnutella), you hash each file to a bitstring of the same hash length.

Now, when you want to reach a particular node (and you have its hash but not its IP), you can do an efficient search by traversing the nodes in the direction of the target nodes. For direction, a distance metric is needed in this case. The distance between two given hashes is simply the result of [hash1] xor [hash2]. This is rather simple and ingenious: you get a value representing the amount of bits by which the two hashes differ. Hence you have a way to measure distances in the hashspace.

Therefore, when trying to locate a node, you don't need to do an exhaustive exponential "ping all my neighbours and get all their neighbours" search; one could say that you are able to follow a vector in the hashspace. edit: by which I simply mean, the most simplistic way to achieve this would be - pick a node from pool/neighbourhood with id/hash closest to target; get id/hash from its pool closest to target; continue until reaching a critical distance within which nodes will be responsible for holding the desired key->value pair. (I'm sure the actual algo will need to be somewhat more complex, as it's very easy to run into dead-ends this way, and so on.)

When there are files involved, nodes whose hashes are close enough to a given key (which is a hash of a file, more or less) are responsible for storing those key->value pairs ('value' differs on implementation, but basically it's another hash pointing to the node which actually has the file in question, if I'm not mixing things up; the whole thing is more complex, with a way to search using (hashed) keywords, etc.) Hence one can implement an efficient distributed search algorithm, where you focus on the hash-neighbourhood of a particular file hash, and get key->value responses from the nodes responsible.

This kind of a system has its disadvantages and possible points of attack. See the wiki article on Kademlia. [1] Probably the most well known type of attack is Sybil attack: [2]

In a Sybil attack the attacker subverts the reputation system of a peer-to-peer network by creating a large number of pseudonymous identities, using them to gain a disproportionately large influence. A reputation system's vulnerability to a Sybil attack depends on how cheaply identities can be generated, the degree to which the reputation system accepts inputs from entities that do not have a chain of trust linking them to a trusted entity, and whether the reputation system treats all entities identically.

Now, Drogulus seems to propose at least a partial way around this, though I suppose it'd still be possible to actually flood/populate the hashspace with garbage(?): [3]

The drogulus has three core components:
* A distributed hash table (DHT) that provides the data store and replaces DNS.
* Trust and identity enforced via cryptographic signing of digital assets.
* Logos [...] (say "log-oss"), a simple implementation of a Lisp like programming language for asynchronously working with data stored in the DHT.

The drogulus implements a version of the Kademlia distributed hash table. The innovation the drogulus brings is that keys and values (items) are signed in such a way that their provenance can be proven and content shown to be intact. Furthermore, users cannot interfere with each other's items stored within the distributed hash table unless they have access to the same private key. Items are self contained and any that do not pass the cryptographic checks are ignored and nodes on the network that attempt to propagate such values are punished by being blocked by their peers.

I don't have time to actually delve into this now, but the next paragraph piqued my curiosity even more - if anyone is into this, would be interesting to hear some comment :)

Logos programs are themselves values stored within the DHT, run in asynchronous "ensembles" that arrive at a consensus and process other items of data stored within the DHT. They are sandboxed and intentionally limited in terms of time (how long a computation may last) and space (how much memory may be used). Since Logos programs are also data there is a mind-bending side effect that Logos programs can rewrite other Logos programs in order to extend the Logos programming language itself. This is an important property: users have the autonomy to grow the Logos programming language to suite their own needs.

So, something something - Kademlia-like crypto-signed homoiconic datastore - something. Hmm.

[1]: http://en.wikipedia.org/wiki/Kademlia

[2]: http://en.wikipedia.org/wiki/Sybil_attack

[3]: http://drogul.us/how.html