Orthogonal Persistence and Algebraic Data Types for documents on Safe Network

The OP is about a very useful functionality. “How to achieve that on the SAFE Network? Let’s think about it!” It’s brainstorming. I didn’t commit to any implementation. Blocks, streaming, etc? Huge search space for ideas, let’s explore! Many would not work. I know very well. You say: “But I know nothing can work!” It’s tiresome.

You picked a particularly broken implementation of an extreme interpretation of a particular detail. Then concluded: THIS WHOLE IDEA IS A FAILURE, I JUST PROVED IT CAN’T BE DONE!

No @neo, you proved your way of doing that particular detail is a failure. Also: You hijacked the thread to be about a small implementation detail instead of the original idea. Not cool.

That’s saying: “Why don’t you go play somewhere else!” Not very respectful. And you are a mod.

Basic implementation of full functionality of OP doesn’t need to change existing design. It’s a layer on top of the original design. Can work with MD as it is. If you say: “It can’t work!” That means the SAFE Network can’t work. Are you sure?

Yes: Minor changes could make this idea work better. Probably. You picked on one such change I mentioned as a “maybe” solution, picked the worst possible implementation, presented an extreme case as the only case and ignored it all is paid services thus infeasible, then “showed” the whole idea is a failure. Okay.

But it does. Do you write programs? I don’t think so. You would know: Programs keep track of things. That’s what programs do for a living. Else they don’t work. This is like: “If you don’t keep track of your money, you won’t have food before pay day.” But you do keep track. Simple. I’ll get a headache. Such a non-argument.

No @neo. Memory is not reserved until used, not on Linux: https://stackoverflow.com/a/911897

That is a change for linux. Not windows or apple OS Nor Unix

So there you found a loophole specific for certain versions of linux. And if you know how OSs work, its really smoke and mirrors since the OS has reserved resources to it in its paging. At the some level resources were reserved, just not in the core memory space.

BUT no matter the memory needed is actually used to hold the pointers and data needed to keep track of the MDs you left open. So its only words on your part and to deflect the issue.

In anycase you have gone from true streaming to blocking the data so the point is mute. You are not using that idea and using what SAFE provides.

Wow misquoting much

You are now putting a layer in the client. To do it in the node is to have all the problems of resources again.

Saying you won’t use resources or it can be done does not make it so. You are still bound by the design of SAFE and of the operating systems they operate on top of.

It was always a layer on top of SAFE Network. You misrepresented my idea since the beginning. Let me quote from OP. (Since then, I added a TL;DR on top.)

Single suggestion to maybe add some new functionality:

You picked a particularly broken implementation of an extreme interpretation of a particular detail. Then concluded: THIS WHOLE IDEA IS A FAILURE, I JUST PROVED IT CAN’T BE DONE!

No @neo, you proved your way of doing that particular detail is a failure. Also: You hijacked the thread to be about a small implementation detail instead of the original idea. Not cool.

I stop. It’s irrational. Maybe you have a need to prove other people’s ideas are stupid. Not the first time I see you attack other people’s mental capacity in a hidden way. Yes you can deny. It’s designed you could. See? At least I say it out loud. More honest. I don’t find arguing with you fun or productive.

@norimi I think you have some good ideas here and it is great to debate them. However, you have a rather confrontational style of communication, which I fear will just close down the discussion.

This discussion was closed down long time ago. It was all just arguing about why a particular detail can’t work. Ever. Okay. But I admit it’s my fault. I should’ve stopped responses after some time.

“Oh so now it’s about…” kind of responses. Got a few of those. “Maybe you should go start your own thing.” Both me and @jlpell got that. Is that not rather confrontational? Just more hidden. Now at last I am confrontational too. Quote me on being confrontational before on this thread or other please. Then I agree my style has a problem.

I think that for most apps, most of the time, storing every single character immediately to the network is overkill. You can persist every character to local storage and then persist for example once a minute or whatever. Worst case scenario is if you have a disk failure and loose a minutes work. If the network connection went offline it would just persist once online.

For any application where the only consequence of a persistance failure is that you would have to redo the work done since last time it was persisted, then storing locally and persisting to the network with regular intervals should be no problem at all. All that could happen is that in extremely rare cases where the locally persisted data was lost you would lose a couple minutes of work that would have to be redone.

There’s cases where data has to be persisted more frequently, but it is not something all users would be doing all the time.

A Google docs type of application in cases where multiple users are writing in the same document at the same time is one example where frequent persistence would be needed. If two users were writing in two different paragraphs, not every single character would need to be persisted immediately, maybe every word or every few seconds. Only if the users were working at locations in the document very close to each other would every character need to be persisted to the network immediately.

Perhaps in some cases data could be sent directly peer to peer, or through an intermediate node for ip hiding, so that multiple users working on the same thing could each persist locally and sync with each other very frequently and persist to the network with slightly less frequent intervals.

Actually no I didn’t. I was saying byte by byte and implementing this at the core level is not feasible under the current goals of SAFE and to implement them at the core level opens the network to attack.

I did say that if you, and it seems you have moved this way, block up the data and update the MDs using the current update mechanism then it is very much possible. (by using a layer above the low level stuff)

Also now I feel that you could make this very much optional for people and have it as an APP running just above the client and under other APPs. Or simply write another client that implemets this.

Then that way you do not require changes to the core which is really all low level stuff and whomever wants it can have this interesting concept/idea

No it was the concept of true streaming which every system out there has moved away from (& now use pseudo streaming == blocks) that I said would (could) not be done in SAFE code without tying up extra resources. And then you keep on that I was stupid for saying it could not be done that particular way and stupid for saying it would require resources. If you want to see it as a personal attack then so be it. But I was attacking ideas and your counter points were not adding up and I pointed that out.

If I was (or do) sprouting stuff like that then feel free to point it out to me in no uncertain terms.