This definitely is 2 different discussion.
- One about
privacy / security
. (The Appendable Data discussion is mostly about this). - Another about
sustainability / performance
. (The DataStore over AppendableData design is mostly about this).
It’s true, but not sure if it’s such a good thing, to be inspired by
Also, the word immutability can be changed for anything in that sentence.
The idea of surveillance is easier for people to accept as they are becoming used to it from the internet they already know.
I don’t think Facebook practices serves as a good measurement of what is desirable. They might be doing some things that are good, and some not, but that’s like all there is to it.
And besides, wasn’t it said that it’s boring to do like it’s already being done (just showing that that argument isn’t really good, it can be used in all sorts of ways).
The heaviest and most real arguments I see is:
- Focus on releasing sooner rather than later
- Network economy shows (?) that the numbers add up.
- (Possibly) Data storage advances show that this is completely a non-issue (do they?)
(mostly in scope of performance / sustainability
)
First point is not much to discuss IMO, only the most critical features qualify as to allow delay of release I would say. One thing at a time is a good device.
Second point though… The one thing that can show if it is sane or not, is the numbers IMO. Do the numbers add up?
And it is about this idea:
It is one fragment of the wider idea about the network economy;
If people are prepared to pay for the PUT, then the network capacity will be there (provided by those who want the rewards) to
1.Hold the data
2.Serve the data
In a sufficiently performant and sustainable way.
So. Is it shown that it is sufficiently performant and sustainable? Or have we identified where it is not, and clearly stated why we comprromise it, and what is gained by doing so?
That would, theoretically, then solve the question about excess duplication coming out of immutability.
If people pay for it, then there will be resources to handle it.
It’s not that it isn’t producing wasteful garbage - it’s just that, if someone thought it was more expensive to set up another non-SAFE layer of security and redundancy for their indexes and current state, then they would instead pay for storing it on SAFE, and that means the resources to cater for it will be there, regardless. Because people will want the safecoin, so they will contribute the resources.
In that case, we actually don’t need to say Don’t publish dog poo now. Because the idea would then be, Dog poo or not, If you pay for it, then resources will be there to handle it. But of course, not publishing dog poo, might be related to a knowledge that it is a waste of resources. Just because you pay for it, doesn’t mean it isn’t waste.
So, if I know humanity right, CryptoKitties and crap consumerism will drain as much resources as always, and there will be duplication of data (draining resources).
The most important thing is that the network can handle it.
Because if the useful stuff can happen, well then OK, the “useless” stuff in a way also enables it to happen.
Next thing (a bit more luxury), is to consider if it’s possible to come up with a smarter design. To not do as it is already done (costs didn’t prevent CryptoKitties). And somehow technically make it less wasteful with resources for humans to indulge in their stupidities (as they always have and always will). That’s a fairly large and imprecise issue, so maybe not realistic to think about for a very long time.
To wrap it up, my question would just be about the numbers, simply: Are they solid? And I would think that is where effort should be placed, just to make them add up. And that would redirect the entire question about immutabilty, towards the network economy. Just a redirect on to that: “It all works, look at the numbers.”
The rest is mostly various levels of philosophy, politics and metaphysics.
EDIT: (I am focusing mostly on performance / sustainability
aspect here)
EDIT2: One more very strong argument: Simpler and more robust code!