Self reference is a technique used to show paradoxes and prove a lot of interesting stuff, like Gödel's incompleteness theorems.
Of course, self-reference by itself is not always bad - e.g. it's the
basis of recursion, which is pretty useful. Paradoxes have two more
components: a variant of the Liar Paradox and an evaluation system. Consider the classic example:
This statement is false.
There are three components here:
The self reference. Here the sentence refers to itself, but any system that can do so will work.
The liar paradox is needed to create the dissonance: The content are contrasted with their meaning.
But
more importantly, the evaluation system is needed to give this
statement context and meaning. Without evaluating the statement (in our
heads), it is just that - a statement.
Only by combining
all three elements will we create paradoxes. Deliciously tagging your
delicious tags probably won't create a system panic and bring it down:
(a) How will we create a dissonance, and (b) How will we evaluate the
this? What can these self referential links give us? The following are
a few rambling thoughts.
* The "tag" tag lives in the same spaces as the other tags. By this, the system includes its own meta-information.
*
The purpose of tagging tags is to add some meta information on the tags
themselves. If I wanted the content of the tag I'd just look at the
list of tagged items (the items - don't forget the items), matching
this tag. Thus we get a recursive reference to the self - tags
(meta-data) whose content (data) is other tags (meta-data).
** We
could build a hierarchy this way: here's my programming tag, containing
the ruby tag, containing Ruby relevant items (the items - don't forget
the items). In fact, this is why I use del.icio.us direc.tor - it imposes an on-the-fly contextual tree on my bookmarks.
**
But hierarchies can also obscure information. This may be good if its
too much to view at once, or may be bad if it's obscuring what I'm
looking for and how to get at it. At uni, I worked for IBM Research on
a sharable bookmarks project (all the rage then. How much has changed
;). Items were tagged and stored discreetly, but presented
hierarchically per user: Tags were not inherently related; Each user
saw all the tags but constructed their own (display) hierarchy for the
tags (and the items - don't forget the items). In that system, tags
were not part of the item space, kinda like a file-system with folders
are distinct from files. (Items could appear multiple times, under
different tags in the tree). When I opened my Comics folder under my
Humor folder, I also saw everyone else's webcomic links, regardless of
whether they also tagged it as humorous or not.
* So if I tagged
all my programming-related tags (say ruby, dynamic and language) as you
did the same (with say perl, python and proglang), when we looked at
sharing information about items we could also share our taxonomies when
categorising these items. Of course, who guarantees that our
taxonomy-taxonomy is the same? Enter recursive self-references :-)
*
Would these taxonomies ever converge? What is the practical recursion
level where the simple process of reviewing and retagging (gardening
your links) is sufficiently stable to expose to you the information you
need?
* Will there be an rss feeds for the contents (actual
items) of my tags tag? Will I be able to see, under my ruby tag things
people have filed under the rails tag? They thought it was obvious, by
I want a simple connection.
If you've read so far, I must applaud
you for sheer tenacity in the face of my obvious insanity. I'll reward
you with an interesting thought experiment - try to experiment in
thinking about your thinking. Try and get an echo in your head. It's a
lovely experience, experiencing your thoughts before and after you
think them, almost atemporally.