I want to improve on wiki and forum technology to make them more conducive to building a source of high quality knowledge. Here are some features I see as key:
- maintaining linkage between related pieces of information
- providing high quality interfaces for adding/editing/viewing information
- enabling storing of specialized pieces of information and query them
- facilitating discussions with a useful end product; one that is more than a sequential list of posts that have to be read one-after-another, in their entirety, to get full context
It all started out as a simple desire for inline editing
— switching edit mode
for every little change can be arduous. Such functionality can be the difference between a user choosing to fix a typo in an article and choosing to leave it be. In and of itself, inline editing would be a very nice feature. However, when inline editing is performed using a compiler, much more becomes possible.
a markup compiler
Any system using lightweight markup syntax needs to transform text, written using that syntax, to HTML. This is done a number of different ways, usually with hand-written parsers. In fact that is how tsunami's syntax
is currently transformed. As you can see if you just clicked that link, this hand-written approach is pretty horrible. A one is to use a compiler
, which is defined
Simply stated, a compiler is a program that can read a program in one language — the source language — and translate it into an equivalent program in another language — the target language;
Some compilers preserve whitespace. I want to write a compiler that transforms markup -> HTML, but preserves whitespace [information] in its intermediate stage. I can then feed HTML character indexes into the intermediate form and get out one or more sections of markup.
Consider how quotations work now: you embed text in a page, give a bit of information about who said it, and perhaps when. There is often no easy way to go to the source of the quote. If there is, you are directed to a page, or even worse, a book or multi-page article. This results in several limitations that you may not have realized — after all, this is how things have always been done.
What if you want to know which parts of an article have been quoted, and how often? What if you want to ask what people are saying about a particular paragraph? To do this now requires much work. I maintain that this should be easy. Moreover, sometimes people don't actually include a quotation, but they do respond to an article. Currently, there is no easy way to see exactly what part of an article someone was referring to, unless exact quotations were used. I think something better is possible.
Imagine being able to know exactly
which text is being referred to, whether it was quoted in its entirety, in an abridged version, or only by reference. Imagine being able to look at an article and see exactly who referred to exactly what. Tsunami will make this possible using two core features:
- a compiler, which will map selected HTML to the original markup
- revision history, so the exact version referenced is always available
With symbolic quoting, it will be possible to record relationships between articles in as granular a fashion as desired. Tangential conversations are no longer hard to follow — each tangent will leave its own trail of symbolic quotations which can be traversed effortlessly.
I have just started using EtherPad
and I cannot believe I have never heard anyone rave about collaborative editing. More details can be found at the link, but let me just tell you that I think collaborative editing will become very
important in the future. I intend to implement collaborative editing directly into tsunami.
I tend to understand systems by perturbing them and seeing how they respond. It is extremely easy to do this in the physical world with materials (like a paper clip). It is harder to do it in the computer world, especially when there are tedious compile-run cycles. Instant feedback should be an extreme priority for all tsunami technology.