The default for computing is data loss
We should likely warn time travelers as we present them the wonder that is the modern mobile phone not to get their hopes up. They're still likely to lose text documents.
Why?
The default for computing is data loss.
For the average user there's still a good chance that when they create a file they'll lose it.
Even if you do everything right, paying money for a backup solution, it's entirely possible for such a backup solution to lose your files or terminate your account.
You can't trust cloud backups or storage regardless of your relationship with the company with the situation only getting worse when we remember how many startups disappear leaving no trace of their data behind.
That this is still not solved in an era when most users have enough storage, compute, and bandwidth to back up their digital life multiple times over is a slow rolling nightmare, an ever expanding bitrot fragmenting our collective history.
I haven't pulled apart the entire story, and what tragedies have resulted in the behemoth of modern computing being fallible here, but the morbid truth remains.
A writer is still likely to lose their novel or their PhD.
A coder is still likely to lose a database, almost regardless of their level of sophistication.
Your friend circle is still likely to lose their discussions and "memeography" as they shift from one transient communication platform to the next.
- Local data: you're likely to have three devices, a few hundred megabytes / gigagbytes of irreplaceable data, and we'll still expect to lose it
- Local databases: the OSS default isn't trivial to use / set up and resiliency instead relies on paid closed source PaaS extensions
- Cloud data: exporting your own data but limited in what is connected to you, let alone relevant to the broader ecosystem
- Nearly equivalent: importing lossily from one service to the next
- Transient data and experiences: game servers that will shut down and never return, file formats that at best require data archaeology, vital data lost in reams of banal statistics, ...
- Are these backups independent, fragmented, and likely to decay themselves in the following few years?
The developers, by implicitly or explicitly making certain practices simple or easy, dictates the type of data safety and data loss the user is likely to experience. Given the developer is far removed from the consequences, especially when the developer is tech savvy and the most vulnerable of audience struggles beyond the simple, this is a problem.
- Does it require user action (or a process that isn't error proof) to begin and maintain backups?
- Is data backed up locally still useful?
- Does it require special software to use? Are there static "rendered" versions that still provide partial value without the underlying tool?
- Does it come with sufficient surrounding context to be understandable?
- Is the user aware of what limitations or errors the backup is constrained by?
- Are they aware of what is or isn't covered by the backup?
- Do they know what "recovery" looks like in the worst case?
- Is the user alerted when an accident might result in their data or backup being compromised?
- How much of the original functionality is maintained after export?
If we want data safety then the end user must have a consistent and well tested process available at little or no cost that is simple to use and understand. Such a data safety layer shouldn't need user intervention beyond the initial setup of the solution and should remain as invisible as possible excepting situations where data loss might later occur.