I see you like to think about data as something tangible. I do too. For example, I don't like the way one learn Lambda Calculus in some schools. You know, by telling that Lambda is the only thing one needs to design anything. In a pure mathematical model, it's plain true. But in a real computer, the *behavior function* (the overall pure function which changes every time the system learns from the outer word) needs to be materialized in some way. The way one materializes it is actually a major concern, especially if you seek for persistence. A naive attempt would be to define the whole system behavior in a single flat source code file, like a "behavior.lisp" file raw-copied in some hard drive. This file would need to be revamped at each system iteration. Naive as I said. The current way to work consists in splitting behavior between read-only flat files on disk (software code and assets) and read/write boxes that one fills with mutable values (user data and various settings). The system behavior is consequently 90% hardwired and the remaining 10% is all about little boxes one fills up with inputs. My thoughts are about finding an ultimate way to store the behavior function of a running system. I want it to be fully plastic and self-indexed. At first, I intended to do yet another object database. But I eventually realized than replacing files by some sets of slot-value pairs (or entity-relation database, or labeled graphs or predicates) didn't fundamentally change anything except from a better data granularity. One still faces a dumb system which can't fetch and manipulate most of the information it owns. Because slot-values objects, relational database, labeled graphs, predicates, XML files, RDF and any existing data storages I've found out on Google are all based upon a single ancestor: the box/value meta-model, which is wrong. Why? It's all about *reification* i.e. making more things tangible for the system to work with. In a box/value based system, one could dedup and hashmap values, but one could not dedup boxes (because their content can't be shared between contexts) and one can't neither dedup nor hashmap a "some value in some box" information at all. This last one -relationship- is not *tangible* for the system. And yet, as I said before, this is where *meaning* resides as bits by themselves are meaningless. If you dismiss graphs but embrace arrow structures (which actually supersedes academic graphs), now you can query the system for such a relationship, like (color-&gt;yellow) and get all the contexts where this relationship is involved. Plus now, this relationship is a first class citizen. You can use it as a referee (an head) or a referrer (a queue) to build up meaningful information. Now computers can natively work on the *meaning* of the data they store. Actually I suppose it's what I find mind blowing.