Everything should be STATIC

There should be no dynamic data that is stored in the network. Rather it should be static. This will allow meshnet to build the ecosystem painless, easy, and communicate directly. Plus it will allow dynamics system to place on top of the static system very easy. Dynamics is a social system for humans while static is a environment system for humans. All data ought to be stored as static because it is an environment resource inside of the network. Static cannot be mutated but it can be mutated into what user like via dynamics. Static value will never change except for the owner of the static value.

Think of this way, the matrix movie where neo finally realized everything can be bend into his favor. He sees everything in bits (0,1). Everything he sees in the matrix is static. He can bend it to his favor by using dynamics, aka his mind. So he takes static information, manipulate it by using dynamics. This is why agents failed to destroy neo because agents are designed as static! They are AI inside of the system but will never able to have that human creativity. AI is just bunch of codes scripted, designed to do specific task. AI can do crazy amount of calculations, and give you the answer because of the static information inside of the network.

To use dynamic system rather than static system has caused a lot of issues for AI, and the people who worked on internet archive website. By I mean, when data is stored dynamic, it is harder for people to find the actual data. The actual data is stored inside somewhere in the dynamic system which requires to be hack into, and find the data. There is an article I posted here before, I forgot which article is it…Edited: Found it! It explain the essence of why it is hard to collect data dynamically today, than it is to collect data statically during the 90s, and early 00s.

So if we were to build decentralized MMO… Inside of the network, everything is white or black. One person pops into view, and put 1 safecoin into the network to build a house he dreamed of. Poof, there is a house for him to use. That is static house. Any other users passes by his house will see his house because it is static. But they cannot access or change it because it is encrypted static information. But if the user does not like the house, he could remove the static information from his viewing by using dynamic software. It doesn’t exactly remove but render obsolete in his viewing. Another user could build a tiny house next to his, and another user build a business opposite side of said house. All users could see information inside of the network but cannot be modified. Thus building a static MMO world, with dynamic user system is the best solution, and gives user more freedom in digital world with property rights. The opposite of second life does.

So the conclusion is to build everything statically 100 percent. That is why I am looking forward to use safe. It is cheaper to put static information inside of the network than it is to put dynamic information inside of the network. Safenet incentive users to save static information, such as toml, json rather than javascript right from the start of the network.

TL;DR - Static means extra customization, 100 percent freedom, and more safe.


We want the dream to act consistant!

That is the thing, though. How do we remain consist when there is no time, no rewrites, and no changes. This is like tron when the first digital men walked through empty space. Emptiness. No specks of a thing in black space. We don’t know how we can deal with changes while having other users to know changes are done by the users.

Time stamp is a good solution but it won’t be part of the core system. Rather 3rd party. Static information could be time stamped, and .git will take it’s information and changes.

There is one ideal way, is to have static information stored in a block. This block holds the history of the changes he put into the network. Blocks can be expendable, and might be a good solution for storing git information. However it does requires more puts. Or we could interpolate with the blockchain. Users provides block storage instead of safe storage but use the safenetwork api to extend it, and have it linked to the blocks. The self-encryption will still be in used. Or we could use safecoin which does deliver 1mb Data Structure. We could swap back and forth, changing data. The new messaging protocol can deliver up to 60,000 messages per second. The capacity of the message is 255kb(might be wrong here). Limited, but it might be doable for building a very basic 2d game like x/o or chess.

History changes need to be minimized without having a huge burden of the resources in the network. We have to change the aspects, and how to define what we can do to minimize the transfer data while maximize the efficiency. Active changes should be done in memory pool or serversafe. Dynamic software should be used inside of sandbox mode on top of the static world. We are passing information here. Information that only applies to the what it is being said.

What about time locks? Time locks could be a good way to keep resource in the network, and when time gives up, poof, it’s gone! This could be a good way to create events in decentralized mmo. Events where people temporarily pug more resources into the network but can return to original state before the event has started. There would be a notification, “warning, new event coming up, if you would like to participate, you need to provide 2 safecoin, plus 5gb. Those will be returned to you after the event.” Those resources could act as a memory pool. Here is a better version.Each of us put ‘jobs’ into the pool, and does things statically. Your animated character, and your palace are stored statically. The software takes statically, and put into memory pool to do things dynamically. This is where we could change things temporarily. We communicate, put things, and do it statically. The software takes it statically, and manipulate things dynamically. We move this bit to right hand corner. And that bit to left corner. What if we change this bit to new bit, it can be reverted to original state without having to call to the network. It is just doing things on user end. Static data could explicit to do things on user end software like animating a character.

These events that choose to be saved, are notified before you participate. When final changes are provided, we update the link but not the data. So it does make a conflicting issue for changes. Hence, another reason to use .git solution. We just follow the git format to keep themselves updated in the static world.

But lets to be honest, servers are extremely useful in gaming. Server has a great memory pool, and deliver data quickly than most standard computer could do. XOR address plug into server-safe. Serversafe function is to take user information, manipulate it, and does things, extending the pool size until the capacity is caped out. Once it capped out, or time is out, the event is ended. It then returns the final data to the users to be saved as .git format. Server will never understand what was being doing or whats being said. Serversafe get compensated by the users who pitch in safecoins. A good 3rd party solution rather than part of core system.

So all of these ideas can be a good way to remain consist. and keep up with the flow.

Just remember that everything we put into the network is just bunch of mumbo jumbo, and nothing knows what it is or what it is doing. We’re just passing information here from there. Punching bunch of holes, data goes everywhere. it’s all meaningless but we’re holding it, and passing it. The only people inside of the network are able to communicate without knowing each other history, and whereabouts. We are closer to each other in digital world than in meat. It’s brilliant. This is .hack// at whole new crazy level. What is the right word replacement for ‘new crazy level’, shinighnies, or something that like that? It is a chinese word.

What you keep in your view is dynamic data. Unless of course you’re willing to create a new static block with all your references +/- the changes whenever your state changes; that’s certainly an option (I think Camlistore uses something like that), but SAFE has already went with a different model with its immutable v.s. (mutable) structured data distinction.

1 Like

Super interesting article btw!! Stuff can’t get lost that easily these days; we have the NSA for that :joy_cat:

But I get the generic idea. I, for example, backup my YouTube playlists every few days: I grew fond of random covers of songs I’ve never heard of by random people from random countries, and those tend to go away quick (some for “copyright” reasons; like some talented kid singing their favorite song is a real danger, right?) Same goes for my favorite tumblrs, random articles I find, and the like; I’ve seen too much cool stuff go forever :scream_cat:

The abovementioned Camlistore thing is about archiving all your stuff, too: one can write import things for blogs, YouTube songs or playlists, like it’s Evernote or what.

1 Like

Camlistore sounds almost exactly the same as safe. It mentions puts and gets, and fuse storage. Just slight different modification on how it is stored. This is interesting stuff here. Good find there!

Exactly. What goes into the network, stays in the network. It shouldn’t just “disappear!” like the article stated. We are in consist state of flux. Maidsafe is the best place to set up as an internet library, but… also while continue to be in the state of flux. That will be a hard one. The issue is how do we remain to be in continuous state of flux without having a huge burden of the resources, and the network? Internet archive took 1PETAFLOP when that article was posted. just think about that for a second here. All of the resources around the world put into maidsafe, rather than servers, network could be in 100s of petaflop. The history changes will be in billions of gigabits per week. How do we reduce the resources + cost of history and flux?

1 Like

No place for stateless? If you’ve covered this I a sorry.

Yes! With a different scope (personal storage, not some worldwide distributed thing) but with very similar ideas about how to solve the problem.

Different kinds of data have different characteristics and requirements:

  • chat logs, live audio recordings, or just streams in general: append only; possible way to store it: mutable (structured data, on maidsafe) buffer, periodically archived as immutable blocks, stored “as is” forever
  • a movie, a music recording, a book, a picture, or any other “write once / read many” kind of products: a chunk of bits, immutable by nature
  • a git repository: it stores frequently changing data, but history is very important; we store each change set as immutable data (but we need to store a pointer to the latest block as mutable data, otherwise we won’t be able to find it)
  • a user’s virtual file system: often modified stuff, constantly in a state of flux, so it’s mutable data by nature; the history may or may not matter, but when it does, the current state can be just dumped into an immutable block to back it up (semantically parallel to saving a snapshot of an EBS volume as an S3 object)

As you can see, for some data, history matters. For others, it does not (but we may still want to do snapshots). For still others, it simply does not exist. Using mutable data for modelling changes where history does not matter is a useful compromise to solve exactly the problem you were talking about: the cost of storing all that flux – some flux just doesn’t matter, so why not just throw it out? :smirk_cat: