so, it’s been two weeks and i’m still thinking about the abstract on open systems design.  the emphasis is on ‘producing content’.  period.  it was almost like i wanted to exclude any kind of higher level manipulation.  the goal was not to design amazing interfaces and intuitive systems – the goal was to simply produce content, and this idea, would in turn change the way we think about designing systems.  the goal is not to present anything.  the goal is to enable presentation.  encourage it, even.

now, this idea, could be very easily applied to journalism.  all we really need to do is design the system to index the feeds.  then journalists everywhere can begin to use the machine.  they would simply take a picture and it would be entered into the system, which now meant it could be tagged and further classified.  Formal and informal classifications would exist, but all of it would come later.  First, just the content.

i think i can build this system.  the problem isn’t the code.  the problem is seeing the whole system, how it is created and how it changes over time.  how do you create something which has a life of its own?  i think the answer to that question is easy – to give life is to make sure your creation can continue without you.  so make your systems self-sufficient.

this open content system needs to be built around a central addressing system.  that is the key.  this can be achieved with path aliasing.  every id can be simply a unique number.  this system will tie in common libraries and authentication schemes through the central control script.  also, every object would have to be indexed at creation.  metadata would only include simple info like user, date, event.  interfaces could be built around any of it.  in fact, my emphasis is on not initially building the interface.  and after the main structure is built, other parties will need to find ways to make the disparate objects related.  after that, interfaces can be built.

here’s the order:

1. content
2. simple metadata
3. addressing
4. informal tagging
5. formal tagging
6. interfaces