Super Massively Distributed Systems

With a message broker you can transmit JSON dynamically to different clients, resulting in "an event driven architecture". The problem with this approach is that the creator of each individual "service" in this network mesh needs to anticipate the usage requirements of all future potential clients, for an infinite amount of possible questions, for an infinite amount of time.

This is the equivalent of anticipating every possible answer to every imaginable question that can be phrased using computer languages, and creating a pre-computed list of potential answers. This is not only awkward and sub-optimal, but also impossible, resulting in that the internet as a whole becomes a trillion times "dumber" than what it needs to be.

Hyperlambda allows for transmitting "logos", and it allows to transmit it securely!!

If this sounds all jibberish for you, then please realise that logos is simply "code", resulting in that servers in such a computing environment would have the ability to "speak with each other, using logic", similarly to how humans can speak with each other using natural language.

Hyperlambda can be securely transmitted over the network, and sent from a client to a server, that executes the code, and returns the result of the execution!

Security concerns

Opening up your server for executing code transmitted by random and unknown clients from around the world is of course normally the equivalent of "software development suicide", because it would literally take seconds before some adversary have applied such huge amount of damage to your system, that it's basically destroyed.

However, since Hyperlambda is a "virtual execution environment", based upon signals and slots, it allows for creating a pre-configured list of "whitelisted keywords", that declares the sum of vocabulary the client is allowed to execute. This allows you to restrict clients from being able to execute malicious code, and only allow them to execute safe code! While still the client is able to transmit generic code, that the server executes on behalf of the client, and returns some result originating from executing said code.

You have now given the machine the ability to "speak"

Spoken Words

I don't know how the world looked like before humans were taught how to speak, but I know it was pretty gloomy before we had general literacy. Similarly to how life was back in the 14th Century, before we invented the printing press, today's IT existence is literally living in "the stone ages". Once we taught ourselves to collaborate on larger tasks, by transmitting "logos" in the form of the written word, this had drastic consequences for the real world, and our ability to conduct science and search for truth. Basically, our level of scientific knowledge entered a spiralling self-sustained "loop", where we could build on top of each others ideas, allowing us to solve problems previously impossible to imagine.

Humanity as a whole became a "super organism"

If you want an analogy here, based upon scientific constructs and ideas we've already established long ago are "scientific facts" - Then try to imagine this from the perspective of cold fusion. When you fuse together 2 hydrogen atoms to create one helium atom, you release immense amounts of energy. If the human mind and "logos" behaves according to similar principles as matter and energy, this implies that such an event where the whole of the internet's individual parts, melts together and "becomes one", would inevitably release more cognitive energy than the sum of all cognitive energy we've applied throughout human history - Simply due to the fact that we've got BILLIONS of existing devices already connected to the internet, and by teaching these to "communicate intent" with each other, would become the equivalent of creating and implementing a single "super organism", where each individual server can be imagined as nothing more than a single cell in that organism, and every single "compute device" currently connected to the internet, would become capable of in theory leveraging this cognition capacity, and the sum of the network's cognition capabilities as a whole.

Before you dismiss this as science fiction or hype, please realise that I've already got code that implements it. So this isn't some far fetched future theoretical system, this is something you can do today if you wish. Below is a piece of code that implements it.

.arguments
   hyperlambda:string
hyper2lambda:x:@.arguments/*/hyperlambda
add:x:./*/whitelist/*/.lambda
   get-nodes:x:@hyper2lambda/*
whitelist
   vocabulary
      get-value
      set-value
      vocabulary
      return
      return-nodes
      yield
      math.add
      math.subtract
   .lambda
return-nodes:x:@whitelist/*

The above 17 lines of code, basically have the capacity to create "a cognitive big bang", AKA; A New Logos Universe! This is because the above code can be wrapped inside an HTTP endpoint within your existing Magic Cloud server, at which point it allows for clients to transmit code to your server, and have your server securely execute said code.

The point being that the "vocabulary" section above declares "a whitelist" of slots, becoming a sub-section of the server's capabilities, restricting the client's access to "speak" to the "vocabulary" specified above, and the client's code is executed from within that whitelist invocation, eliminating its ability to execute code not explicitly whitelisted by the server's admin.

Don't want a malicious client to delete files? Then don't WHITELIST the slot that deletes files!

And different whitelists can be associated with different clients, according to the trust level the administrator of the server is willing to hand out to individual clients. And yes, it's really that simple!

Authorisation

Since Magic allows for fine-grained access control, based upon Role Based Access Control (RBAC, the same as Kubernetes implements), this allows you to hand out different execution rights to different clients. For instance, my children and my wife might be allowed to download our family album photos, while some random stranger would only be allowed access to photos from my public folder.

This again mimicks the relative trust level of a client, according to who he or she is relative to the person owning the server, allowing the administrator of each individual server to declare what he wants others to be able to do on his system using RBAC.

In previous implementations, I've even gone so far as to demand each Hyperlambda payload being cryptographically signed with a private key, that has been previously imported into the server by the client, and associated some access rights to individual slots by the server's admin, in accordance to the admin's instructions.

This allows us to have a "default" trust level where it's impossible to do anything malicious, while individual clients can be granted extended rights, effectively "fusing" the militarized zone and the demilitarized zone into one single environment, using cryptography, cryptographic signatures, and JWT tokens to attach execution rights to the client's request.

If you think this sounds like mumbo jumbo and pseudo science, realise I'm literally doing it in the following video. Thank you for reading 😊

Psst, Singularity you said? Been there! Done that! 😂