Information Navigation

When you want to find something, there are a few ways. The current systems allow us to group information into files, which are put into folders. To find something, we navigate a tree-structure until we reach the data nodes - files.

I think an alternative system would be tags, metainformation, and inherited tags and searching, as opposed as filenames and browsing. Not that file names are not allowed, but any file name can simply be another tag. What differentiates a tag from a file name?

• you do not have to know all the tags to access some piece of information
• you can emulate a file structure through inherited tags. that is, when you place some information into one tag, it automatically recieves other tag attributes
• metainformation may be extracted from the file and searched. when files are written, they will be run through metainformation strippers, that extract useful information for searching. for example, text documents may have special metainformation extractors that extract titles, important words, key words etc.

On the other hand, tags does pose a computationally more intensive way to find files. Data structures such as hashes or other relational database techniques might have to be used to implement this sort of file system.

To access information, I envision that we would use both selection and refinement. We can give a set of search terms to the information navigator. If the search is enough, then we will only be faced with one file, or possibly a group of homogeneous files (with similar structures). We can view these files because any type of information can be viewed. We can then either directly (via a function explorer) or indirectly (through a user-interface that you can load) call some functions to bear on the information.

Interestingly, a function explorer is not any more direct than a user interface - a function explorer is simply a viewer that views a list of all functions grouped into hierarchies or otherwise.

An interesting failed project

"When and why" to do "what it does"

This might sound reductionistic, but computers are there to: show information, do stuff to information, get information from people/hardware/internet and to store information.
And one important aspect of computers is thus the "when and why" to "do stuff". Usually a computer would be sensible and "do stuff" at appropriate and sensible times, by definition, I suppose. So when is it sensible for a computer to do things?

• When you tell it to. Through some user interaction, via a user interface, you tell a computer to take some information and "do stuff" to it
• When a certain condition has been met. In other words, when there is a cause. For example:
• when a certain time occurs, or
  
• when a certain thing happens, or
  
• when a certain, possibly derived, value is attained
• That is about it I think. Unless your computer does something for no causal reason, in which case, it is an intelligent computer, or otherwise, even non-deterministic, and thus not very smart to talk about today.
  

So what is the point?

The point is that if we can enumerate all possible "when and why" a computer will do something, we can separate the "when and why" from the "what it does", by delegating the "when and why" bit to the operating system to manage. The "when and why" for user interface could range from:

• command line commands as triggers
• mouse clicks
• voice commands
• any form of input really

This decouples the action from the trigger, allowing a more flexible and separated system. Although at the cost of speed.

First Class Things

In computing, a first-class object (also -value, -entity, -citizen), in the context of a particular programming language, is an entity which can be used in programs without restriction (when compared to other kinds of objects in the same language). Depending on the language, this can imply:

1. being expressible as an anonymous literal value
2. being storable in variables
3. being storable in data structures
4. having an intrinsic identity (independent of any given name)
5. being comparable for equality with other entities
6. being passable as a parameter to a procedure/function
7. being returnable as the result of a procedure/function
8. being constructable at runtime

-wikipedia

First class objects are very useful because of the properties 2, 6+7, and 8. The benefit of first class stuff would be that you can store it for later use, even if what you are storing is very complicated.

• For example, you can create a user-interface layout, and store that as a file. That means that different configurations of user interface are merely files which describe what the user interface is.
• Another example of using first class things is when we turn information resource locators into first class objects. This allows us manipulation of our query independent from manipulation of the information that the query points to.
• A third example would be file logs - that is, our information system would keep a log of all functions that have been invoked to reach a file. This type of object would be able to be used for file history purposes, such as bibliographies, sourcing data, finding sources of good/bad data, direct file modification via modifying the log, the ability to undo any operation applied to a file.
  

First class stuff is also related to the model-viewer-controller approach, because what we are enforcing is that every piece of information has a way to be viewed. This could be implemented as some sort of inheritance of a show function that all things must inherit from.

However, our objects are often more than data - they have functional purposes. For example, the user interface, resource locators and file logs have a functional purpose. As we have described, when we modify these files, we are modifying the very functionality of the computer. Changing a resource locator would allow us to see different information, changing the interface information would change how our interface is laid out on the computer. This can be solved by basing the system on a set of many reflectors - that is, all programs are dividied into a component of core logic which is separated from presentation, description, and other information.

Such a separation is good because, as mentioned, it allows us to do higher order operations on our information, but more than that, it allows us to reuse the same functions and techniques that we have used for plain information on higher order data, since they are also first class stuff.

Operating Systems

I would really like to see a great operating system that is not of the windoze or unix/linux/*nix type. But what would an operating system that does not live off these two giants be like? My ideas migth often be unachievable, slow, or not useful, but here is what would be cool.

1. Operating systems and Program split: is it useful to have a very clear distinction, rather, does the operating system needs be an unchanging thing? Security and safty can be managed even if there is a lack of distinction. Many of the following ideas can be implemented in a program, however, if all programs will end up implementing this, why not make it a more basic service offered by the operating system. The question then becomes one of how much we can put into the operating system, and what a program actually needs.
   
2. Super-flexibility: i would like to see the whole operating system as a very small core operating system bit that exposes mechanisms to do things. So the operating system might be more of a plugin command station. If the entire system ran on managed code, that might work.
   
3. Powerful information system: well, computers are really there to do a few simple things: show information, do stuff to information, get information from people, hardware, internet and to store information. The current way of doing this is by separating this information into files, and ordering files into directories. A better way of doing things is to give information tags, and to search for information.
   
4. Powerful and Flexible viewing: in terms of showing information it would be great if we are shown the essence of the information, rather than one aspect of the information. That means that we can specify what way we would like to view it. Sort of like how windows explorer can show files as icons, as lists etc. We should not be limited by how we can view the same information
5. Lazyness: the operating system should only do what it must to do. If there are some things that it must to do, it should only use as much resources as it can get away with.
   
6. First class everything: do you like anything you see on the computer. Save the information down on the computer. Everythng is first class, so you can apply functions on whatever you save. User interfaces are first class, you can directly edit it - like how you can edit a toolbar, except this is for all user interface elements. Settings are first class, so you can load it in an independent common setting editor. Maybe a structured language like XML would be useful. We can make all functions curryable since a curried function is another function.
   
7. Separate/decouple all components of programs, and allow total distribution: if you have a chess game, and you distribute the interface across two computers on a network, you have a networked chess program. if you used managed code, you can ensure that you only use a grainuality and protocol that suit the distribution. Because you decouple things, you achieve higher reliability. Implementing the model-viewer-controller or a variant idea.
8. Separate functionality: why have many little bits of functionality that make up a program when you can simply separate the functions? So for example, instead of having a text editor, we have a text viewer, plus a set of text transform functions (which may take user input or other forms of input), which takes the text from one poitn to another. Even something like pasting or typing a bit of text would be a function, which may look something like insert_text(source, destination)
   
9. Logging: all file operations (or information operations) are logged as a set of functions that have been applied this gives you the power of undoing for free, but also gives you a backtrace of all raw sources of information. Since the log of what has happened to a file is a first class object, we might even have a file composed only of a log, which can act as a file.
10. Separate the representation from the information content: i suppose that is what Object Orientedness istrying to do, but I am sure that there is a better way than objects. Or, maybe an reformulation of the idea.
    
11. Choice and non-connectedness: when the computer wants information, the programmer creates a dialogue box to ask for information. Instead, what should be done is that a query for information is made, and passed onto whatever type of input program there is. That is, much like the model-viewer-controller view, we can decouple input from the program. The program merely gives a query for information. We can then search the computer for this information, query the user for information (via web interface, mobile phone sms, dialogue boxes, swipe card interface... anything) or anything that gets the information
12. Layered: the operating system must present different levels of abstraction for different level of uses.Some users may be more comfortable with the familiar windoze interface. So that is what the OS looks like, but as you strip away abstraction, the system will become more flexible, and more of an "object/information management system". because we remove abstraction, we can get more flexibility and interconnectedness
13. List-edness: J (APL descendant) rules because it allows you to process one element just like how you would process an array of like elements. If we use managed code, when a function is called, we can automatically write in a managed loop around the program, and even make sure that the program does not run twice, it merely does all operations twice.
    
14. Never do anything (more than) twice: since everything is a function of some sort, and all functions are recorded, we can see that when a person does something twice, the computer can be made to recognise such a loop. it can then generalise the loop by providing generalised inputs such as a list of inputs. Since a list of actions is afirst class object, you can save this and use it later. So we can get macros for free if we log. In fact, when you do such a process, we can be lazy and simply append the relevant operations onto the (first class) file operation log. When the information is accessed, it will then do the processing, or alternatively, it will do it n the spare cpu time
15. Reflection everywhere - since anything is first class, even metadata about how a program runs will be storable.
16. Flows: http://vvvv.meso.net/tiki-index.php?page=screenshots [warning, lots of pictures] flows allows us to visualise the process of function composition
17. Transparent: we will make many things like compression, encryption, network access transparent because they are just convolutions of information access. We can implement these as interceptors on our flow charts.
18. well, i am sure there will be more ideas from you! yes, I need you! please help. thanks
    

Anyway, regardless of whether this will work or not, I think a nice name for the OS will be Tao. I tried to base these the above ideas on the following concepts from the Tao/Dao.

• It will allow the sage to experience without abstraction (via removable layers) and accomplish without (too much) action.
• It will treat all things equally (as first class objects).
  
• It will draw upon experience(macros/operation lists) to accomplish.
  
• Once the purpose is achieved, it will retire (lazily).
  
• It will be scarcely known.
  
• It will use the unchanging(first class objects) to represent motion.
  
• It will deal with small problems(fine grained functions) to deal with the large.

Hello world.

Hello, this is the site of windozer, who has many things to do about computers and stories.

Well, actually this is just going to be a rant about some of my wierd computer and story ideas.

My main interests are:
1. write a cool operating system
2. write a program that will write a novel or at least the plot - no need for natural language generation
3. trivialise thinking

What I believe I can achieve without your help:
1. A blue screen of death
2. A chose your own adventure program
3. Trivial statements that are useless

So please, if you have any interests in these topics, or you find my ideas stupid , please reply! I will appreciate both types of responses.