This is what registers allow today.
It is good that basic functionality is restored.
But what about scalability and reliability?
Can register have millions of records made by thousands of users and at the same prevent users from breaking data structure?
When was it removed?
Reliability is what we are testing
I don’t know what you mean here.
A register has an owner. It can be only owner can update or anyone can update. They have a limit and to extend the limit we need to include link field or similar that allows a trail to be followed. The issue with that though is the latest entry is at the end of the trail, So it can get cumbersome.
Are you thinking about something else perhaps, such a a CRDT type document editing?
Think of a register as an append only list, it’s no more than that. So for publishing lists of immutable data that works, but for more complex things there is more register logic there that allows forks etc. We are not using that in the current API we are looking at for the initial network as it’s much more complex API, even though it allows much more complex apps.
The current laser focus is simplicity and that is what gets us there, any further complexity is just not being considered right now.
I tried to test registers. Created register 67b176705b46206614219f47a05aee7ae6a3edbe850bbbe214c536b989aea4d2aab150ff9df87cb076e854d42d178c6273161c2e216f53ed685f89faa80cdae321724fa3081e099bb11c516d2ecaaa5b, then according to safe register help edit (<entry> The entry to add to the register), tried to add some entries.
What I see is that entries are not added, but replaced instead.
Either I’m not using them properly (most likely), or something wrong with them.
Can anyone say what my register contains?
Are you sure?
How can you tell the entry is replaced if you are not seeing the register?
When you read you will get the latest entry, but as I said above, simplicity for now, so this works and then later dive into all sorts of weird and wonderful use cases.
We just won’t get sidetracked, no matter how hard folk push. The team are extremely focussed right now and won’t deviate till launch 
(later we can unleash the whole potential of registers and CRDT data types for all sorts of amazing things)
I was explaining mechanism which was implemented in days when Safe Browser existed.
There were many rewrites since then, having such mechanism not removed at some point looks like a miracle for me.
I am not sure what you are poking at here, but it’s best to stay on track with the network we currently have and it’s currently published capabilities. I know docs are lacking, but that is fine for now, docs.rs is fine for now, but a large part of work for us is API polishing and publishing.
If there is something you think was in a maidsafe only run private set of nodes that is not in place now then you are right, there was a crap load ton of stuff we deleted to make what we have work. Not registers though, they never existed in the time you are alluding to.
Stupidity lies in complexity and genius lies in simplicity as far as code goes. At least in my opinion.
So here we are demonstrating the power of simplicity and the speed of progress we can make with that simplicity. We are never returning to the complexity of fully ordered systems, it’s a totally unatural and broken dogma.
Yes and yes!!!
I doubt that such primitive allows to make complex data structures, which users of internet are accustomed to.
Of course, in presence of malicious users, whose goal is to break data structure and service, which operation is based on such structure.
Nothing more than explained above ^^
Proving that foundation is solid is called sidetracking? Ok…
register get commands gets it and show to me.
Added explanation to command may be good thing.
Or you may call it sidetracking…
Tell ye what. As you love the last word, here is a message with no content of any great meaning for you to respond to in as insulting a way as you can muster. Then go sleep a bit better with a huge smirk on your face. But still we are not sidetracking for ye mate
There must be loads of stuff for you to pick away at going back to 2017 and mischaracterising in your beautiful way.
Oh I will let chatgtp answer this one for me
In a basement lit by RGB’s glow,
SAFE Network devs were putting on a show.
“Encryption is key,” they all agreed,
“To make this the best network, indeed!”
But then came Vort with a box of donuts,
And a thought about using quantum flow nuts.
He said, “Imagine the user, so pleasantly surprised,
When their files are served with a snack, super-sized!”
Or you may call it sidetracking, a cognitive maze,
Away from encryption, they began to graze.
“Ooh, let’s add a feature that predicts the weather!”
“Or make it a social hub, where folks gather together!”
Days turned to weeks, they added a game,
A SAFE Network café, even a virtual flame.
The project was turning into a digital zoo,
While the notion of security simply withdrew.
Finally, Sarah, with her spreadsheets in hand,
Brought them back to the very first plan.
“We’ve got to secure data; it’s what we said we’d do,
Not create a circus, or a digital brew.”
So they reined it in, though it’s never quite plain,
How a simple sidetrack can reroute the brain.
Lesson learned, they doubled down on their goal,
For it’s easy to wander, but hard to keep control.
Hi All, 
Im new and missed the last testnet, but thought I would give this one a go as the project looks interesting, I like the concept 
thought I would post my findings, as might be some use in them / or not…
Running a node on Ubuntu 22.04, 2Gb Mem, 2 Vcpu behind double NAT (Natted at the Edge onto internet, and Natted on local Dev firewall) - have punched a static port from a public IP, all the way down to the node, and seems to work as node has been up overnight, and I have files ?
running the node with;
export SAFE_PEERS="/ip4/178.128.45.252/tcp/32923/p2p/12D3KooWRokYkFYg698Wk1fm7RcDGj4tJ9dsdgDx6FgSypuhm8Pm"
export SN_LOG=all
safenode --log-output-dest data-dir --port=32923
PID: 1972
Memory used: 63.8008MB
CPU usage: 2.9%
File descriptors: 772
IO operations:
rchar: 504042542
wchar: 657265738
syscr: 639509
syscw: 2829636
read_bytes: 23060480
write_bytes: 661737472
cancelled_write_bytes: 0
Threads: 5
Records: 43
Disk usage: 19MB
I’ve got a few weard things happening, and wondered what you thought ?
-
The logs are being created under …//logs/safenode.log - however, it seems to be automatically log rotating every ~1657085 to safenode.log. - I’ve literally getting hundreds of them - is there an environment string or something I can do to stop the log rotation, or change the size ? I’ve had a quick look in /etc/logrotate.d/ incase I had a rogue entry, but nothing…
-
I’ve seen that you are working on getting QUIC going (UDP), but i’ve noticed I have 8-10k TCP sessions generated running a node, with 95% of of them stuck in FIN_WAIT_2, as the client (other nodes ?) isn’t sending the final ACK, so the sessions are stuck in the state table until they are timed out - my quick fix was to set the TCP Idle timeout to 1s at the edge, down from 60s to prevent the session table using up all the firewall ram - only mentioning it incase it has any significance.
-
uploads worked perfectly last night, was able to upload a few 1MB files, and download all of them again - today have tried uploading, and it’s not having any of it - can still download the files from yesterday though - is this because the seed I’m using to connect to the network in that group is now full ? should I be pointing the client at my own node now ?
root@safe01:~/uploads/1mb# safe files upload cat_file1.mp4
Built with git version: 794fca7 / main / 794fca7
Instantiating a SAFE client...
🔗 Connected to the Network
Loaded wallet from "/root/.local/share/safe/client/wallet" with balance Token(99999999920)
Preparing (chunking) files at 'cat_file1.mp4'...
Making payment for 4 Chunks that belong to 1 file/s.
Successfully made payment of 16 for 4 records. (At a cost per record of Token(4).)
Successfully stored wallet with cached payment proofs, and new balance 99.999999904.
Successfully paid for storage and generated the proofs. They can now be sent to the storage nodes when uploading paid chunks.
Storing file 'cat_file1.mp4' of 1048576 bytes (4 chunk/s)..
Failed to store all chunks of file 'cat_file1.mp4' to all nodes in the close group: Network Error Could not retrieve the record after storing it: 8b622c9f4d03254b9724a79a8c04feaa46305bc948d4d1ac7b7f43c38f5b3a48.
Writing 61 bytes to "/root/.local/share/safe/client/uploaded_files/file_names_2023-09-01_13-56-12"
Thanks,
Jad
Is explanation of what should be classified as sidetracking and what not is classified as sidetracking?
Nice feeback
I am not sure, cc @chriso
Nice one for us to peek at. cc @joshuef I do hope we see QUIC very soon, but this could be a fail to disconnect thing too (potential attack vector for tcp but not so much for quic)
It could be the seed nodes have changed somehow, but being full should not have been an issue unless the whole network became full. Need to check. You can connect first to your own node, it will do no harm and your local routing table should find more nodes
The could not retrieve after store error is suspicious though. Can you try downloading again please, just in case it’s a timing issue (trying to read before fully stored)
Hi, I was just wondering if you could clarify exactly what is happening here? Are you seeing more than one log file? I actually wasn’t aware we had enabled rotation in our configuration.
Little more explanation of what I was talking about.
It is known that every piece of information can be presented as sequence of bits.
Also every algorithm can be presented as Turing machine.
If system can manage bits, it can manage any information.
If system can execute Turing machines, it can execute any program.
These are primitives - implement them and anything needed can be made of their combination.
The question is: can registers act as such primitive for Web 2.0-like services?
I like approach of complexity emerging from simplicity, but for it to work, primitives should be carefully designed and maybe even have some properties proven.
I agree that some sidetracking prevention should exist, but I highly doubt that this topic is really at the side.
upd. I wonder how “atom” for user ↔ service interaction looks like.
Rotation is happening but possibly not as a system config thing. He’s correct that it is creating a lot of rotated logfiles, seems to be happening faster than previous test nets presumably because there are more log messages being generated ATM.
Thanks for the info. If possible, could you please quickly paste a list of what your log directory looks like at the moment please?
Not right now but I can tell you it contains safenetwork.log and numerous (earlier) files with that name and a timestamp appended after a second ‘.’
OK, thanks.