Hi, new here.
I’m interested in MaidSafe, and was wondering just how anonymous IDs are?
I plan on making an imageboard with this technology, or, if things don’t pan out, with IPFS, and I don’t want posters to have defacto poster IDs by merit of other users being able to find that poster’s ID and being able to see all the other posts that ID made on said imageboard.
So, in essence, I need to know two things:
Can anonymous posters have their posts viewed by other users due to their Unique ID?
If, for some reason, I wanted poster IDs, as a thread or board-level setting, would that be possible thread-wide?
This is up to the APP. Your APP could maintain a “rating” for the images and the user sets controls on what kind of content they want to see. So the rating system would be multi-facet with maybe category, how good it is, parental ratings and so on.
As anonymous as the user want it to be. The user could tell others about their ID and thus lose some measure of anonymity or all if they broadcast too widely. OR the user could not tell anyone about their ID and only by following the ID in your or other APPs can they piece together something. OR the user could generate an ID every time they do something. So anonymous as the user actions make it.
Up to your APP really, does it provide a way to link the user uploads/images together? some sort of index? If so then others could find the images belonging to one ID
I am not sure what you are really asking here. I say that because its upto your APP to incorporate these things. It sounds like you want a forum (or similar) and the image ID is used as the poster ID. Again that can be done if you write the software to do it.
IDs on SAFE are key pairs and can be used anywhere so an ID used on your image APP could be used by the person in a forum APP and they would be the same ID thus you know its the same person (or group if the person shares the ID with others).
Thank you for the response, neo.
Yes, I want to set up something very similar to a forum - an imageboard, which is based off of text BBS.
So, I could set up a moderation team to flag illegal images (we all know what that may be) on my APP (If needed).
Would it be possible to straight up delete those images? I’m still a little fuzzy on how SAFE actually works, but from my understanding you can have mutable and immutable. Is this for the entire APP or can it be more granular as in content? (eg: images)
I guess to make my question a little more pin-pointed: Can a user’s content be identified in any way other than them straight up posting their ID? It seems like from what you said, a user’s content can be tracked and viewed by their ID.
Would having the user generate a new ID every post for that post be an excessive load on the network? This wouldn’t be needed in threads on boards where thread-level poster IDs are enabled. Is there a more efficient way in ensuring a user’s other posts can’t be seen within SAFE’s framework?
On an imageboard, typically there is a post frame, an image on the left side, and then text content. You can input a name, email, and post options, but those are all optional, and the default “name” is “Anonymous”.
On the technical side, at least traditionally, a post is usually a DB table with various fields, including the image hash (for quick lookup) and the post text.
The index, I suppose, would be the post number, so 1, 2, 3… etc.
Okay good, so I have more control here than I thought.
In general, I’d like there to be as little identifying information as possible, anywhere.
So, if the user has the same ID as some other APP, a user can possibly see that ID’s content if they get ahold of it. Would this also apply “locally” in my APP?
You could use the members themselves to also do the ratings and moderation. You could even write it such that people could apply moderation according to their preferred “moderators”/raters.
The user owns the data so no, the user themselves has to delete the image. But you can control the indexes to those images and thus remove the image from being indexed.
Even if you use mutable data, the user owns it. The only way around that is to have created all the mutable storage that will be used. If you expect you need 1000 MDs each day then you would need to create MDs to cover that in advance before they are needed. This implies you have your own APP to do this maintenance work. Then while the user owns the image stored in a field of the MD you can still delete the MD. This obviously costs you and the users have to agree to store their images in your MDs.
So yes you could delete images by using MD’s, but the cost of creating the MDs is on you and the cost of index MD is on you.
MDs store up to 1MB of data. They can have multiple fields that can can have permissions set. So you could have an MD that has a field for an image and anyone is allowed to write to the field and you could then change the permissions of the field in the APP once the user saves their image so that no one else can modify that image. And you still can delete the MD if you want to.
You could set up a number of ways to to identify images. There is no need to store the SAFE ID they are using with the image.
If you do not provide a way to track IDs in your APP then it by chance that people could track IDs. that means they view one image and note the ID then view others images and only when they come across a match of IDs can they “track” the ID. Of course if you do not store IDs with the images then not possible unless your APP somehow links them.
No load on the network since it is done client side and only if the user wants it stored in their account is there any load. But surely the users are not posting at a fast rate so its like once every so often. Just part of normal operations for the network if the user wants to remember his ID.
That will be possible on SAFE. It may not be a SQL DB but a noSQL DB. Anyhow I am sure others can help once you start designing the APP.
Look up DECORUM as they are developing protocols and systems for this sort of thing.
I( touched on this before. If your APP does not providing searching by ID then its only by chance they will come across their images.
You can have your own ID system too so that IDs only apply to your APP and then you can do as you please.
Okay, this makes sense.
My plan was to have the APP (client) automatically host some SAFE content so it could post freely after whatever minimal amount of time, and have the APP (client) upload the post content/image itself, and to have my APP (server) take care of indexing, moderation, etc if necessary.
Anyway, thank you neo for helping me out here so much.
That answers my questions as far as I can tell.
I may reply to this thread later asking about more, as things progress.
Since uploading “costs”, would doing something like liveposting be prohibitively expensive, or impossible?
Liveposting is: Sending part of a post to all the other clients very quickly, so it seems like the user is typing live, and then on commit the post is finalized.
I imagine this could be done with ${post_index}-${part_index}, and just joining it all together on the committed post client-side, or while live, joining together the current parts until commit.
Not impossible, but prob not v1 easily. You could connect directly to each client and show keystrokes etc. but not via network push notifications at v1 as it’s not on the roadmap. It would require almost streaming the chunks then a commit type signal which is not currently part of the release plan.
Okay, so since SAFE is serverless, it would be the typing client sending messages to the rest of the clients?
I would probably have a server-like node for that, then, so that excess amounts of bandwidth aren’t used up for the typing client, and have the server-like node just send those to the rest of the clients.
Is there a github repo for the project that (can possibly) handle “network push notifications”?
I’d like to make an issue and hopefully get it on v2, or maybe a patch for after v1.
As well for streaming the chunks, I’d like to see if this is at least a viable possibility for SAFE.
No there is not yet, it would appear in safe_vault and safe_client_libs perhaps. Right now we released the network fundamentals to try and stay very focused on v1 delivery. This would require an RFC and discussion to make sure this kind of system would not leak IP addresses or other users information in the process. I know that is not encouraging for right now, but we need to be tight right now with any v1 work to make sure there is no deviation for launch. It is certainly an idea worth much more discussion though.
