Leo Git Python Lisp and the holy file system

Leo - being able to make new views of data from other files - treating data as a tree

Git - Content tracking anno 2008,

Python - Batteries Included

Lisp - Code is a AST

What If the basic data-structure of content was richer in this direction and all our tools needed to comply with that format - What if all our activities ended up being transforms, sources and sinks for this format. What If all containers was built from this format as a building block. I'm just thinking these thoughts and noting XML ...

For example how would present this file in a shell? insert links to other parts? skip markup?

What kind of markup would always have a meaning independent of the application? I would say at least

1. Grouping and sub Groupings e.g. the basic tree representation

2. Version Data For Versioning undo redo stuff as well

3. Linkages Between files So parts of files can be embedded in other files

4. Marks that Just Mark Segments of the file

5. Metadata Tags That Correspond to usual Metadata Of file Systems files and directories.

5. Signal Marks, Sends Signals When Shown

The Task: Find the Batteries that fits this, find your python, find out about how unix would be designed

As an example, a mark is something that you typically would like to associate with a content, you don't consider the character, you consider the (character x markinfo) e.g. you build a natural framework in which the mark flows with the content inside the program. If contents ends up in a window as text the marks sits right next to it, latent or visible in some way. Consider for example a global bookmark manager, you keep bookmarks to different locations in your data. signaling to a specific bookmark should imply that the application containing that data shows a view over it.

Consider a notifier mark, when a marked word is shown, you signal that the mark is shown to an application via a callback that collects this flow of information. Now you could have a tool that associates keywords and give you links to associated material, say that you have a database of 1000 programmers, using different tools and that you have marked all keywords in your 10M lines of code, as people learn new stuff about the code and as they surf the code, the keywords will signal, and you will get patterns of how people track different notions. Just rest on the security issues with this, In the best of worlds this tool could be helpful though.

As another example I personally think that keeping code in mostly AST is good enough for programming and this means that by standardizing the tree format all tools that handles trees in a nice way will be available to your data format, actually you could consider having a live code object in a FUSE like environment and letting different tools and users work on it at the same time. being under a version control you should easily be able to collaborate. Why? Because git is tracking a tree, you could as well flavor it right into the bones of the code being just that, a tree. Actually you have to think more because the idea is that we actually use a DAG, but you could just as well assume that the content in the link belongs to the tree and as if it was immersed directly meaning that changes to the source is recognized as a change in a multitude of containers

Use your imagination what would you append to this?

Good Night!