> I predict that 10 years from now normal relational databases have infrastructure for shared, authenticated and verified rows and columns
Agreed, though with the caveat that this is for transactional systems closer to the settlement/long term storage layers where the added assurance is useful. The performance hit for a traditional (linear) log is too large otherwise... though you can do a causally consistent version instead to reclaim some of the performance. But for more analytical workloads, I doubt it.
I'd actually go one step further and predict that in 3-7 years we'll start seeing early-stage startups, in fields completely unrelated to blockchains, using a smart contract enabled enterprise (private) blockchains for the majority of their backends... dropping most of the backend application layer (currently filled by django/rails/etc) in favor of a Vue/React private blockchain arch.
The _reason_ such a shift might make sense is what you get in return:
- distributed w/ BFT (no _there's a problem with one of the nodes in the etc.d/consul cluster and its down/screwy_ problems)
- complete commoditization of high availability + disaster recovery
- good enough un-sharded write performance (a few 1000 tx's a sec) with unlimited read performance (writes are the expensive part)
- high-security env comes for free
That being said, the current state of smart contracts (specifically solidity but also plutus and tezos') makes this prediction laughable as, at the moment, writing/writing safe blockchain apps is quite difficult. However, if something _like_ Kadena's Pact (disclosure: am founder) finds traction it doesn't look too crazy.
Something like a procedural SQL for key-value DBs + capability-based auth + native REST support... which Pact effectively is when you strip away the blockchain context.
Given that the language is designed for safety and for technical executives/lawyers to be able to read if not write (similar to Excel's/SQL's usability by non-devs) it's stupid simple for a dev to learn. For example, a toy TodoMVC (Vue+Pact): https://github.com/kadena-io/pact-todomvc. Moreover, when you write a contract in Pact you get, for free, a REST API (pact types have native JSON reps) + an RDBMS representation. As if that weren't enough, it has a H-M type system (opt-in) + formal verification.
The only way this prediction can happen is if the smart contract language is far more effective at traditionally app-layer roles (e.g. django, rails). I'm not sure if it'll ever come to pass, but the combo of trivial to learn (and thus hire for) + abundant safety + formal verification could be enough to achieve it.