Quote from: likeatree on March 21, 2017, 05:14:40 PM

Thank you for your input. I look forward to hearing your design.

I will get into wall of text mode to give a better picture lol

The thing is originally my background is i got into programming browser component in the start of the 2000, with components based on ATL and NPAPI/XPCOM, with code that had to be portable over two browser interface, which include also the events related to the system windowing, the component model XPCOM/COM with their own interface definition language, and the system to link the IDL interface to javascript binding.

Also related to the idea there is direct show, and it's when i started to understand how microsoft were totally genius with this system, because it allow people to develop new codec and filters, to be integrated into standard filtergraph and being used in any application. Result, microsoft they just do the skeleton for plugin system, and all application based on it can use all the codec and filters programmed for it.

And same goes with activeX style programing, to extend browser functionality.

The catch ? Well it needs completely hardcore type definition to fit with COM, IDL, dll, registry based, with the whole interface to define and instantiate those complex object.

I got my brain totaly smoking on this one for a few year in the 2000's, with this whole mess of defining complex component to be instantiate by blind application, with massive surtyping and all this.

But the real trigger is when i started to program with AS3, flex builder, and android sdk, i started to really see all this component based pattern everywhere, based on XML data definition like flex with eclipse, WSDL kind of programming with flex, it completely made the trigger to me.

I post this to explain the background, and it fit with the github discussion of iamnotback on it, it's completly the problematics my brain have been crunching in the past years, and it's completely in the center of the problematic with distributed application where some component or module can be run on top of the block chain by node that are blind to it's data type.

From there , there is two main path to get to real distributed application, there is the way how i explained a bit before, with some block being marked as being pure data block, replacing the merklle root by the hash of the data, and a system to mark those block like why not with a path system '/application/myapp/mydata' in the block data, and then some option to tell the client which path he want to download, and the other he just need to keep the block header to keep the chain coherent.

After for the data itself, the thing i have in mind and turning around for a while, is to have those block also being able to contain structured data, that are related to module, why not with some kind of OLE like thing based on data type and component implementing interface to deal with them, and then you could have something like a coinbase like input to mark the type of the data, and eventually the parent block for hierarchized data, and then the members of the object as outputs of the transaction.

Like this it would allow to define tree graph like thing on the block chain, with data hierarchy, and runtime defined object, that can be loaded in json like runtime type based on the transaction.

Each member of the object can be changed with a transaction based on the output that define this member.

And then having components module loaded by the node to implement the interface either via rpc or direct http request outputing html5 data, or xml/xslt.

The general idea is this, but there are maybe still caveat, but i'm polishing the plan in my mind

Add to this a little pinch of darpa browser experience science, and it's effectively the eth killer Cheesy