When planing something, you normally focus on „what needs to be done first.“ I tried to take another perspective and imagine the project was already finished and I had to document it retrospectively. This way of thinking really helped me, so I want to explain the idea behind it and its outcome.
Now imagine that the developers of some system would have the chance to peek into the compendium about the system at hand before even creating it. They would have a clear vision of what lies ahead and of the possible complications that might arise, and would avoid many mistakes. Note that they need not read the whole thing cover to cover: A glimpse into the outline might be enough to boost their imagination.
Application to my project
Today, I sat back and had a look into the future: What would a compendium about Cubenet look like? At the bottom of this page, there is an outline of a possible book about it, and it serves several goals: It may give the reader (that’s you, for example) an overview of what’s inside Cubenet, but for myself and future developers it also is a map, showing what aspects need to be dealt with.
New scope to think about
Of course, this is not the first list of aspects of Cubenet. I had such outlines ever since, dealing with what needs to be build. But this one also has some bullet points for the aspects outside of Cubenet, which are closely related to it, in a way of what needs to be considered. This difference makes it much more exhaustive and thus more useful. On the other hand, there are even some details missing in this view. I spend the last weeks figuring out what language to write Cubenet in (C++) what interfaces to provide (C functions and stream over stdio, pipes and network) and how to build it (CMake). You won’t find any of those in my outline, and if this compendium was ever written, you probably wouldn’t find it in the full text neither.
And of course, this is only a fake, I did not really travel into another time to come back with this list, I just made up that future in my head so I could document it in some retrospective way of thinking. I’m currently fooling myself into believing that this _is_ the future, which is kind of ridiculous, but anyway, it kind of helps.
An example of a new insight
Just an example: Cubenet will be cool even without any special language. But at some time, you will want to have an expression language to dynamically evaluate properties. And you will want to have a scripting language to make those computations even more complex. And application developers will want something that integrates nicely with Cubenet. So I conclude that there might be a whole range of custom languages, but if I anticipate this, I could try to create a single language that fits all those cases, or I might find that this is impractical. I really found that out while creating this outline, because at first, those were separate bullet points on different ends of the list, but when sorting it into my fictional compendium, they eventually found each other and are now related.
Do I have to consider everything?
For some of the aspects of that outline, I already have a deep understanding and sometimes even a solution for each related problem I can think of. For other aspects, my mental model is more abstract, and on some of them, I’m completely clueless and only have a vague idea on why I put it on the list at all. I really need to handle those cases where I have no idea. Anyway, I could start to implement parts of Cubenet soon, without having everything laid out. As long as there is some coarse plan for each aspect, this is enough, and the details are on another page.
And of course, I can’t possibly know if my list is anywhere near completion, because I don’t know yet of what I currently don’t know. Ok, here’s the outline as it appeared somewhere in my head today, and I’m pretty surprised that I was able to write that down in about 20 minutes while listening to a lecture (which I had heard once before). Thinking about it for several years really pays of, and I remember that when I wrote my Bachelor thesis only a few months ago, I took several weeks to get to an outline that was as complete and well ordered as this one. This is because I wrote about portability of Java, a topic that was only on my mind since a few months (and which is actually not as trivial as it might sound!). So I did not expect that much of todays short brainstorming.
- Purpose and characterization of digital information systems
- Information Theory
- Knowledge, Information, Data, Communication, Reality and Cognitive Science
- Micro- and Macro-Theories, world knowledge
- Logic, Contradictions, Reasoning, AI
- Data Structures
- Linear space, Symbols, Trees, Graphs, Relations, Sets, Tuples, Vectors, etc.
- Categories and Inheritance
- Common ways to implement information systems (the subsections of this one really need to be reordered. The way they relate to each other seems multidimensional to me, so how would I get them into a hierarchy?)
- For personal use
- mobile devices / appliances
- World wide web
- For enterprise use
- Middleware / SAP
- Active research in KM and AI
- RDF / OWL
- Multi agent systems
- File systems
- Database management systems
- XML and related techniques
- For personal use
- Problems of current approaches
- Conclusions and overview of Cubenet
- Domain models and data
- Equivalent of Web Browsers
- Identity and identification of real world entities
- Merging and splitting of non-unique identifications
- The Cubenet meta data model
- Graph based view
- Tuple based view
- Standard serializations
- Text based
- Special data types and use cases
- Measures and Dimensions
- Spatial and Time based data
- Table based
- Mathematic structures
- Natural language text and Documents
- Graphical and geometric data
- Native binary data
- Collaborative, distributed data modeling and editing
- Remote invocation, information vs. intent
- Topology, roles and data flow in local and global networks, and within single machines
- Peers, Repositories, Hubs
- Emergent Structures, Neural and semantic associative networks
- Push vs. Pull, Callbacks, Observers, Subscriptions
- Standard network protocol and optional enhancements
- Security, Cryptography and Web of Trust
- Privacy, Copyright and Micro-payment
- Custom Syntax and Languages
- Path, Filtering and Query
- Expressions, dynamic evaluation and Scrips
- Paradigms and languages for application development
- User Interfaces
- Libraries and system calls
- Data access Library API, implementation and usage
- Legacy systems (here you find some of the techniques from the first block. This duplication is on purpose.)
- Data from legacy systems
- Legacy systems for representation and interaction
- Bidirectional updates with legacy systems
- RDF / OWL
- Relational data bases
- Object oriented systems
- Subsets of Cubenet and interoperability
- Random and Pseudo-random numbers
- Efficiency, Optimization and Determinism
- Future development
- Known problems
- Needed infrastructure and spin-off projects
- Artificial intelligence
This outline will not be updated in-place. But there is a copy in the Cubenet redmine, which might eventually be kept up-to-date for some time.