JayFresh

UploadLog

YourName — Wed, 05 Mar 2008 10:02:57 GMT

date	user	location	storeUrl	uploadDir	toFilename	backupdir	origin
22/01/2008 16:18:26	YourName	/	store.cgi	.	index.html	.	ok
22/01/2008 16:52:59	YourName	/	store.cgi	.	index.html	.	ok
22/01/2008 16:54:53	YourName	/	store.cgi	.	index.html	.
22/01/2008 17:00:33	YourName	/	store.cgi	.	index.html	.	ok
22/01/2008 18:40:20	YourName	/	store.cgi	.	index.html	.
22/01/2008 18:44:02	YourName	/	store.cgi	.	index.html	.
22/01/2008 19:18:06	YourName	/	store.cgi	.	index.html	.
22/01/2008 20:30:33	YourName	/	store.cgi	.	index.html	.
24/01/2008 09:47:34	YourName	/	store.cgi	.	index.html	.
05/03/2008 10:02:57	YourName	/	store.cgi	.	index.html	.

PageTemplate

YourName — Wed, 05 Mar 2008 10:02:40 GMT

<div class='header' macro='gradient vert [[ColorPalette::PrimaryLight]] [[ColorPalette::PrimaryMid]]'>
<div class='headerShadow'>
<span class='siteTitle' refresh='content' tiddler='SiteTitle'></span> 
<span class='siteSubtitle' refresh='content' tiddler='SiteSubtitle'></span>
</div>
<div class='headerForeground'>
<span class='siteTitle' refresh='content' tiddler='SiteTitle'></span> 
<span class='siteSubtitle' refresh='content' tiddler='SiteSubtitle'></span>
</div>
</div>
<div id='controlsContainer' refresh='content' tiddler='ControlsContainer'></div>
<div id='mainMenu' refresh='content' tiddler='MainMenu'>
</div>
<div id='sidebar'>
<div id='sidebarOptions' refresh='content' tiddler='SideBarOptions'></div>
<div id='sidebarTabs' refresh='content' force='true' tiddler='SideBarTabs'></div>
</div>
<div id='displayArea'>
<div id='messageArea'></div>
<div id='tiddlerDisplay'></div>
<div id
</div>

Important things

YourName — Wed, 05 Mar 2008 09:58:29 GMT

sorting out contacts into who is interested in open source and should be targeted with blog posts
corporate open source manifesto
tiddlytemplating (TT) SEO work with Simon (and Fred)
TT core changes with Fred (and Simon)
TT template gallery with Nick
TiddlyBlogging
changing blog into categories: cartoons, tiddlywiki, javascript, book reviews, mashups, ???
supporting the TiddlyWiki groups more - why? to make myself more credible?
getting into a rhythm of checking TW groups, select blogs, and commenting
writing good blog posts and starting drafts as I think of them instead of needing to do one-offs
finding out where the regular geek events in London and making a programme of attendance, and sharing with Osmo so they know
suggesting visual display of Osmo commitments (in permanent pen, so you can strike-through but not erase)

Rules of Fresh

YourName — Wed, 05 Mar 2008 09:50:58 GMT

Everyone reads things that resonate with them. I try and remember to put mine here.

Don't metaphorically piss on people
Beg forgiveness rather than ask permission
Celebrate things
Show don't tell
No hassle
When the shit gets too deep, pull up your waders

An ideal blog would have

YourName — Thu, 24 Jan 2008 09:47:00 GMT

Digg this
Blog reactions badge
Comments
Trackback (can this be done with blog reactions? Or Blogger-style google links?)

TiddlyWebsites

YourName — Tue, 22 Jan 2008 19:49:00 GMT

Current thinking

21/1
What have I learnt? Right well, we've got the wikifier as the templating engine, which has the standard formatter matching a lot of what we need. The reason being that Jeremy's listRelated plugin does something pretty simple - takes a wikitext template and renders a bunch of tiddlers (and any related to them) through this template. The template here makes much use of the <<view>> macro to display relevant bits of the current tiddler. See RssTemplate.

Jeremy's thinking that we only need new support for the looping in the template, and the direct inclusion of tiddlers. Then you'd be able to say "here's some output html created using a template and some tiddlers" and that would be a TiddlyWiki plugin. The further step of linking it to the save mechanism would be a core modification.

(Just had a thought: the listRelated plugin supports subTemplates, so could that be used for rss items? The template would be the outside template and the subTemplate would be the items. Although the {{customClass{{{subClass{content}}}}}} syntax exists to let us nest spans. It's a bit ugly though...)

The way you'd run the plugin would be:
<<listTemplate tiddlers template params>>
where tiddlers is an array but could also be a filter expression e.g. [tag[!excludeSearch]], template is the tiddler with the template in it and params ought to be the data you want to be able to refer to in the template, such as any user data.

We need / need to fix

Extension to <<tiddler>> so it supports encoded output
To take the listRelated code and make it work for this case
Extension to filter syntax in e.g. filterTiddlers() to allow for negation - !
To make sure the template plugin works when the templates are wrapped to make them display nicely
Can't currently nest macros e.g. <<macro1 list:"<<macro2>>">>

Supported by `<<view>>`

GMTdate : <<view modified date>> (for the tiddler)
Title : <<view title>>
Description: <<view text wikified>>
Tag: <<view tag>>

This is going to need looking at because we'll need to encode the text for title and description!

Not supported by `<<view>>`

GMTdate : for the tiddlywiki / date now
{loop array as var} : loops through array, with each item called var (note: if array is a TW macro, it will be executed and the result used as the array); {loop} is terminated with {endloop}
this_year : returns the year
TiddlerName : just loads the content of the Tiddler
tiddlerPermalink tiddler : returns the permalink for a tiddler (perhaps an extension of commands.permaLink?)
${var} : as variable passed into the template processor
{func params} : a template function

20/1
Ok, so the SEOTiddlyWikiPlugin generates a directory structure of files, but they link back to the TW version, and we don't want that. Uses simple syntax in the template to create the files. This doesn't look as sensible as cook's approach (that Martin showed me), which uses HTML comments. This is better because it's not inventing a new templating language. Fudge fudge fudge. The intention is for me to be able to select a bunch of tiddlers somehow (in this case, it's by not tagging them with 'excludeSearch'), then click build and for the system to build a static version of my site. I'm not sure right now whether a page per tiddler is right. It probably is. So, I need to refactor the templating, stop the redirect and then we're kind of there... at least for prototype-iness. Can post at that point.

Cook has entries like  and if a line in a recipe matches that, it gets inserted. So if there are lots of entries, you just end up with lots of inserts into the end html file e.g. 'tiddler'. My feeling about doing it within tiddlywiki is to match on div id's maybe? That doesn't work for multiple entries... Tags? Aha. Just use our own recipe files. So, the constituent parts are: the builder plugin (e.g. SEOTiddlyWikiPlugin) to collect and write the files, a template, a recipe and some config stuff to say what the root is, etc?

We also want a CSS file. We need to be able to edit one tiddler, publish that and for the effect to just update what needs updating, for example it might affect the sitemaps and the index file (in the case of a blog post).

I think the areas we're adressing here are:

General website publishing
- SEO
  - sitemaps
  - individual pages for content (not sure how much of a difference this one makes)
  - titles being picked up not locked in div attributes
Blog publishing specific
- Sharing
  - Digg, reddit, newsvine, del.icio.us, etc.
- Posting into multiple places
  - Not good practice, but could shadow content on e.g. wordpress.com if you were unsure about the TW-powered site working properly
- Commenting
  - Not sure how this is going to work ask Simon

Templating

It's become clear that some sort of templating method other than that suggested by cook is necessary to get us going with the simple RSS case. I've been looking at JST, AjaxPages and Smarty (which is apparently a very good templating framework, but runs in php) to get an idea of how other people have gone about this. It slightly bothers me that we need to add complexity, and I am trying to discover what the simplest possible system is that we need for the RSS case to work. One idea I had this morning (21/1):

use tiddlers macro (which, if it doesn't exist, is plural version of <<tiddler>>)inside the template e.g. <<tiddlers [tag[!excludeLists]] item_template>>, where item_template is a template that would be passed as a parameter to the view macro (which is included after a suggestion by Jeremy that I see if it is useful in this situation).

We are fortunate enough to have certain constraints to work with, particularly that data is going to be tiddler objects. Others include:

keep any application code out of the template, as these are for designers

Q. marks

how does search work when it's over multiple files?
- ...maybe we do the search in the tiddlywiki and return results from there. Somehow.
What decides the directory structure?
- ...it should look RESTful
- ...see below to see how SEOTiddlyWikiPlugin does it
If we want to preserve some of the TW browsing experience, how much JS would need to be copied along and what would this look like in the template?

Asks

...would be nice to be able to say "export all tiddlers tagged with

so-and-so tag" :-)

Collection of notes about using TiddlyWiki to create static web pages:

function

PublishMacro - publish tiddlers as HTML files to a subfolder - http://jackparke.googlepages.com/jtw.html#PublishMacro
- ...can publish single tiddlers
- ...pretty darn snappy to do a publish of a tiddler
- ...publishes css file as well
- uses the format() style to create templates - in my opinion, pretty complicated and ties the use of this template to this specific example
SEOTiddlyWikiPlugin - to save files per tiddler using a template - http://www.superphysique.net/#%5B%5BSEO%20TiddlyWiki%20Plugin%5D%5D
- ...this works by creating a directory for each tag
- opening a file redirects to the online version
- file contains plain text content of tiddler (cool for mobile experience perhaps?)
- also saves sitemap.xml and urllist.txt files for Google and Yahoo which includes list of generated html files
  - See http://www.google.com/webmasters/sitemaps/ to register your

sitemap.xml file

why we'd change SEOTiddlyWikiPlugin
- the part to focus on is putting a recipe file into the templating step - this allows us to have more than one tiddler in a page for example and separates the spec of the content from the layout a bit more

ChangeModePlugin - to switch template and stylesheet - http://tiddlywiki.bidix.info/#ChangeModePlugin
If just speed is your concern, you could split your data and use Udo's "IncludePlugin" - http://tiddlywiki.abego-software.de/#IncludePlugin

usability thingies

author mode - http://groups.google.com/group/TiddlyWiki/msg/def6e878fe7f12e8
color palette viewer - http://groups.google.com/group/TiddlyWiki/msg/7ebf401cf6ab3c72

related discussions

ListTemplatePlugin

YourName — Tue, 22 Jan 2008 19:18:00 GMT

Name:	ListTemplatePlugin
Description:	Displays a filtered list of tiddlers along with links to related tiddlers
Author:	JeremyRuston
Source:	http://www.osmosoft.com/#ListTemplatePlugin
CodeRepository:	http://svn.tiddlywiki.org/Trunk/contributors/JeremyRuston/plugins/ListTemplatePlugin.js
Version:	0.0.4
Date:	Nov 27, 2006
Comments:	Please make comments at http://groups.google.co.uk/group/TiddlyWikiDev
License:	BSD License
CoreVersion:	2.2

ListTemplatePlugin displays a list of tiddlers, each of which is followed by a sublist of related tiddlers. What
constitutes a "related tiddler" is customisable, as is the template used to display the list and sublist items.

This version ships with handlers for relationships to support RippleRap's convention that a tiddler called
"<title> from <author>" is taken to be a comment by "<author>" on a tiddler called "<title>".

- "raps": returns all tiddlers that are comments on the specified one
- "rapped": if the specified tiddler is a comment, returns the tiddler that it applies to

Usage:

<<ListTemplate filter:"[tag[note]]" rel:"raps" template:"MyTemplate" subtemplate:"MySubTemplate">>>

What I'm aiming for here with any rewrite:

<<ListTemplate filter:"[tag[!excludeLists]]" template:"RssTemplate" params>>

It needs to be able to support recursion, so that subTemplates make sense. We can store data needed for subTemplates in params so it can be passed through to subTemplates. The content is passed in either through a filter for tiddlers, a tag to get tiddlers, or a space-separated list. We'll support more as we go along, but this is what we need for RSS.

The parameters are as follows:

Parameter	Description	Default
filter	A tiddler filter expression that filters and sorts the tiddlers to be listed	(none)
rel	The relationship of the sublist	raps
template	A template to determine how each tiddler in the list is laid out	"ListTemplatePlugin"
subtemplate	A template to determine how each tiddler in the sublist is laid out	"ListTemplatePlugin by YourName"

The optional template parameters specify the name of a tiddler that contains the template to be used. The template is specified
in TiddlyWiki format (not HTML), and can use the macro to extract particular fields. For example:

Item ''<<view title>>'' by <<view modifier>>
^^last saved on <<view modified date>>^^

//# Ensure that the plugin is only installed once.
if(!version.extensions.ListTemplatePlugin) {
version.extensions.ListTemplatePlugin = {installed:true};
config.macros.ListTemplate = {
defaultTemplate: "<rss><<view title>></rss>",
};
config.macros.ListTemplate.handler = function(place,macroName,params,wikifier,paramString,tiddler)
{
params = paramString.parseParams("anon",null,true,false,false);
var filter = getParam(params,"filter","");
var tag = getParam(params,"tag","");
var field = getParam(params,"sort","");
var template = getParam(params,"template",null);
var list = getParams(params,"list","");
if(template)
template = store.getTiddlerText(template,this.defaultTemplate);
else
template = this.defaultTemplate;
var tiddlers = [];
if(tag) {
store.forEachTiddler(function(title,tiddler) {
if(tiddler.isTagged(tag))
tiddlers.push(tiddler);
});
// Q: Why are we only sorting if we've searched by tag?
if(field) {
if(TiddlyWiki.standardFieldAccess[field])
tiddlers.sort(function(a,b) {return a[field] < b[field] ? -1 : (a[field] == b[field] ? 0 : +1);});
else
tiddlers.sort(function(a,b) {return a.fields[field] < b.fields[field] ? -1 : (a.fields[field] == b.fields[field] ? 0 : +1);});
}
} else if(list) {
tiddlers = list.readBracketedList();
} else {
tiddlers = store.filterTiddlers(filter);
}
if(tiddlers[0] instanceof Tiddler) {
for(var t=0; t<tiddlers.length; t++) {
var tiddler = tiddlers[t];
var wrapper = createTiddlyElement(place,"div",null,"ListTemplateTiddler");
var wikifier = new Wikifier(template,formatter,null,tiddler);
wikifier.subWikifyUnterm(wrapper);
}
} else {
// now we assume we are working with a simple array of text
for (var t=0; t<tiddlers.length; t++) {
var t = tiddlers[t];
var wrapper = createTiddlyElement(place,"div",null,"ListTemplateContent");
// in this line, tiddler refers to the parent tiddler running the macro
// Q: is this right?
wikify(t,wrapper,null,tiddler);
}
}
};
} //# end of 'install only once'

SubTemplate

YourName — Tue, 22 Jan 2008 19:16:00 GMT

<item>
<title> SubTemplate</title>
<description> <item> <title> <<view title>></title> <description> <<view text>> </description> <<ListTemplate list:"<<view tags>>">> // loopy loopy {loop tiddler.tags as tag} // <category>${tag}</category> // {endloop} // pending fix for ${...} <link>${tiddlerPermalink tiddler}</link> <pubDate><<view modified date>></pubDate> </item> </description>
Error in macro <<ListTemplate>>">>
loopy loopy {loop tiddler.tags as tag}
<category>${tag}</category>
{endloop}
pending fix for ${...} <link>${tiddlerPermalink tiddler}</link>
<pubDate>22 January 2008</pubDate>
</item>

RssTemplate

YourName — Tue, 22 Jan 2008 18:55:00 GMT

<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>JayFresh</title>
<link></link>
<description>a web hangout for an Osmosoftonian</description>
<language>en-us</language>
pending fix for {this_year} <copyright>Copyright {this_year} ${username}</copyright>
<pubDate>{GMTdate}</pubDate>
<lastBuildDate>{GMTdate}</lastBuildDate>
<docs>http:blogs.law.harvard.edu/tech/rss</docs>
pending fix for ${...} <generator>TiddlyWiki ${version.major}.${version.minor}.${version.revision}</generator>
Error in macro <<ListTemplate>>
</channel>
</rss>

ListTemplate Test

YourName — Tue, 22 Jan 2008 18:54:00 GMT

Error in macro <<ListTemplate>>

SubTemplateIdea

YourName — Tue, 22 Jan 2008 18:50:00 GMT

<item>
	<title> <<view title static>></title>
	<description> <<view title html>> </description>
	{loop tiddler.tags as tag}
		<category>${tag}</category>
	{endloop}
		<link>${tiddlerPermalink tiddler}</link>
	<pubDate>{GMTdate tiddler.modified}</pubDate>
</item>

<<save RssTemplate filter:"[tag[exclude]]">>

Playing with custom formats

YourName — Tue, 22 Jan 2008 17:57:00 GMT

content}}}

hello there}}}

Error in macro <<dtstart>> - Error in macro <<dtend>> }}}

Playing with custom formats}}}}}}

Hmm... they don't seem to work - clashing with the code markup plugin I've got?

Wikifier, Formatter and ListRelated documentation notes

YourName — Tue, 22 Jan 2008 17:00:00 GMT

Wikifier

The wikify function:

function wikify(source,output,highlightRegExp,tiddler)
{
if(source && source != "") {
var wikifier = new Wikifier(source,getParser(tiddler),highlightRegExp,tiddler);
wikifier.subWikifyUnterm(output);
}
}

It creates a Wikifier object and then calls wikifier.subWikifyUnterm.

wikifyStatic returns the html directly.

wikifyPlain calls wikifyPlainText on a single tiddler.

wikifyPlainText calls wikifier.wikifyPlain on the text.

highlightify calls wikifier.outputText.

The `Wikifier` Object

Constructor takes a formatter. getParser figures out which one. config.parsers is examined but is empty by default, which means that in the default setup, calls to getParser return the global formatter object.

wikifier.wikifyPlain calls subWikify on itself
wikifier.subWikify calls either subWikifyTerm or subWikifyUnterm depending on whether it has a terminator provided or not (see below). Example uses are in the gradient macro's handler, where it is called with a terminator, and wikifer.wikifyPlain where it is called without.

subWikifyUnterm is the function that gets called by wikify and wikifyStatic. wikifyPlain and wikifyPlainText calls subWikify with one argument, so that ends up calling subWikifyUnterm as well. The function finds the strings that match with the formatter, outputs whatever is before the first as ordinary text, then goes into a loop through the matches until they run out. The mechanism for figuring out which part of the formatter and therefore which handler to call depends on the result of an exec() call being an array where the elements correspond to the paranthesized parts of the regex - if there is a match, that element contains something in it, if not, it is undefined. After the matches are finished, it outputs the rest of the text. The handlers tend to wikify their contents, so the wikification process is recursive. The upshot of this is that care has to be taken to keep the regex's lastIndex property and the output pointer in check.

subWikifyTerm is similar to subWikifyUnTerm. It takes a terminator regex to match the end of the string in question and wikifies (again a use of recursion) whatever is in between a formatter match and a terminator match.

wikifier.outputText outputs text without wikifying it. Copes with highlighting text.

Formatter Object

At startup, a formatter object is created that contains config.formatters, which is a set of rules about how to turn wiki syntax into HTML. The Formatter constructor collects these into formatter.formatters and their regex match strings into one long regex called formatter.formatterRegExp. formatter is returned by getParser as a default.

I have noticed that some functions use the global formatter object when creating their Wikifiers: wikifyPlainText, highlightify.

A formatter object has a variable called "termRegExp". The functions in the core that use subWikifyTerm are often called with this.termRegExp as the terminator: handler of heading, list, quoteByLine, wikifyCommentForPlugin, wikifyCommentForTemplate, styleByChar, customClasses, formatters;
In the table formatter, there are two terminators: rowTermRegExp and cellTermRegExp; these are both used in the handler;
createElementAndWikify also uses subWikifyTerm and termRegExp and is used as the handler for: quoteByBlock, boldByChar, italicByChar, underlineByChar, strikeByChar, superscriptByChar, subscriptByChar.

listRelated

handler gathers all the tiddlers you've asked for via the filter or tag paramaters, and sorts them by a field if you've provided that. The template and subTemplate are set as well. For every tiddler in the list, a new wikifier is created with the template as the source and the standard formatter, along with a reference to the current tiddler in the loop. The related tiddlers are then found and wikified next, with the subTemplate.

ListRelatedPlugin

YourName — Tue, 22 Jan 2008 16:18:00 GMT

Name:	ListRelatedPlugin
Description:	Displays a filtered list of tiddlers along with links to related tiddlers
Author:	JeremyRuston
Source:	http://www.osmosoft.com/#ListRelatedPlugin
CodeRepository:	http://svn.tiddlywiki.org/Trunk/contributors/JeremyRuston/plugins/ListRelatedPlugin.js
Version:	0.0.4
Date:	Nov 27, 2006
Comments:	Please make comments at http://groups.google.co.uk/group/TiddlyWikiDev
License:	BSD License
CoreVersion:	2.2

ListRelatedPlugin displays a list of tiddlers, each of which is followed by a sublist of related tiddlers. What
constitutes a "related tiddler" is customisable, as is the template used to display the list and sublist items.

This version ships with handlers for relationships to support RippleRap's convention that a tiddler called
"<title> from <author>" is taken to be a comment by "<author>" on a tiddler called "<title>".

- "raps": returns all tiddlers that are comments on the specified one
- "rapped": if the specified tiddler is a comment, returns the tiddler that it applies to

Usage:

<<listRelated filter:"[tag[note]]" rel:"raps" template:"MyTemplate" subtemplate:"MySubTemplate">>>

The parameters are as follows:

Parameter	Description	Default
filter	A tiddler filter expression that filters and sorts the tiddlers to be listed	(none)
rel	The relationship of the sublist	raps
template	A template to determine how each tiddler in the list is laid out	"ListRelatedPlugin"
subtemplate	A template to determine how each tiddler in the sublist is laid out	"ListRelatedPlugin by YourName"

Item ''<<view title>>'' by <<view modifier>>
^^last saved on <<view modified date>>^^

//# Ensure that the plugin is only installed once.
if(!version.extensions.ListRelatedPlugin) {
version.extensions.ListRelatedPlugin = {installed:true};
config.relationships = {
raps: {
text: "raps",
prompt: "Tiddlers that are comments on this one",
getRelatedTiddlers: function(store,title) {
var from = title + " from";
var len = from.length;
var tiddlers = [];
store.forEachTiddler(function(title,tiddler) {
if(title.substr(0,len)==from)
tiddlers.push(title);
});
return tiddlers;
}
},
rapped: {
text: "rapped",
prompt: "Tiddlers that are commented on by this one",
getRelatedTiddlers: function(store,title) {
var tiddlers = [];
var re = "^(.+) from (.+)$";
var regexp = new RegExp(re,"mg");
regexp.lastIndex = 0;
var match = regexp.exec(title);
if(match)
tiddlers.push(match[1]);
return tiddlers;
}
}
};
config.macros.listRelated = {
defaultRelationship: "raps",
defaultTemplate: "<<view title>>",
defaultSubTemplate: "<<view title>> by <<view modifier>>"
};
config.macros.listRelated.handler = function(place,macroName,params,wikifier,paramString,tiddler)
{
params = paramString.parseParams("anon",null,true,false,false);
var filter = getParam(params,"filter","");
var tag = getParam(params,"tag","");
var field = getParam(params,"sort","");
var relationship = getParam(params,"rel",this.defaultRelationship);
var template = getParam(params,"template",null);
if(template)
template = store.getTiddlerText(template,this.defaultTemplate);
else
template = this.defaultTemplate;
var subTemplate = getParam(params,"subtemplate",null);
if(subTemplate)
subTemplate = store.getTiddlerText(subTemplate,this.defaultSubTemplate);
else
subTemplate = this.defaultSubTemplate;
var tiddlers = [];
if(tag) {
store.forEachTiddler(function(title,tiddler) {
if(tiddler.isTagged(tag))
tiddlers.push(tiddler);
});
if(field) {
if(TiddlyWiki.standardFieldAccess[field])
tiddlers.sort(function(a,b) {return a[field] < b[field] ? -1 : (a[field] == b[field] ? 0 : +1);});
else
tiddlers.sort(function(a,b) {return a.fields[field] < b.fields[field] ? -1 : (a.fields[field] == b.fields[field] ? 0 : +1);});
}
} else {
tiddlers = store.filterTiddlers(filter);
}
for(var t=0; t<tiddlers.length; t++) {
var tiddler = tiddlers[t];
var wrapper = createTiddlyElement(place,"div",null,"listRelatedTiddler");
var wikifier = new Wikifier(template,formatter,null,tiddler);
wikifier.subWikifyUnterm(wrapper);
var rel = config.relationships[relationship].getRelatedTiddlers(store,tiddler.title);
for(var r=0; r<rel.length; r++) {
var sub = createTiddlyElement(wrapper,"div",null,"listRelatedSubTiddler");
wikifier = new Wikifier(subTemplate,formatter,null,store.fetchTiddler(rel[r]));
wikifier.subWikifyUnterm(sub);
}
}
};
} //# end of 'install only once'

The RSS recipe

YourName — Mon, 21 Jan 2008 16:26:00 GMT

template: rssTemplate
tag: excludeLists

DefaultTiddlers

YourName — Mon, 21 Jan 2008 10:57:00 GMT

Twitter Hacks

YourName — Mon, 14 Jan 2008 20:06:00 GMT

IDEAS for TWITTER HACK ARCHIVE

At Le Web 3, Ev Williams mentioned in his talk that Twitter can be thought of as a command-line. This struck a chord with me. I believe there is a sub-set of Twitter's 3rd-party applications that are built to make use of Twitter's nature as a command line. I dub these "Twitter Hacks" after the impression they give of using Twitter in a way it was not designed for.

To qualify for being tagged with "twitterhack", a service will pick up on something about the syntax of a Tweet and respond accordingly. This is different from services that simply track various keywords and display and aggregation of them (e.g. PoliTweets).

Twitter Hacks show that Twitter can be used as a device-independent, global command line that sits on top of a large user-base. This suggests several things for the future of applications that take advantage of Twitter: for example, you could create a service that takes in commands, via Twitter, from various input devices. For a business, there is a cost-saving to be had, as well as a rapid launch and the flexibility of multiple ways of interacting with customers.

People who have written about this:
http://www.horsepigcow.com/2007/04/17/twitter-as-your-command-line-interface/
http://zeroinfluence.wordpress.com/2008/01/09/clouds-using-twitter-as-a-command-line-service/
http://www.techcrunch.com/2007/03/27/twitter-becomes-mobile-dev-platform/

Name	Description	Command-line usage	Do you need to follow a Twitter user?
d	direct message to a user	d @username hello	No, this is a built-in function
@	"reply" to a user	@username I disagree	No, this is a built-in function
PlusPlusBot.com	Give people cred or take it away	@username++ / @username— for your last blog post	@plusplusbot, although they are thinking about using "track" instead
Foamee.com	Give someone a pint of beer	@ioubeer / @ioucoffee @twitterscreenname for being an amazing human being	@ioubeer / @ioucoffee
Hashtags.org	Convention for adding additional context and metadata to your tweets	I can't believe anyone would design software like this! #microsoftoffice	@hashtags
TwitterMap.com	Plots locations of tweets on a map	Going to the office. L:3000 6th Ave, New York	No
TwitterVision.com	Like TwitterMap, but a nicer app	L:work=300 Alameda Parkway, San Jose, CA 92012	No

Further developments: del.icio.us scans for keywords? ranked hierarchy?
Post this to: Twitter Fan (twitter.pbwiki.com), run by Chris Messina

Wild ideas for TiddlyChatter

Jon Lister — Fri, 02 Nov 2007 16:15:00 GMT

Ok, so here's an idea - why don't we let the lid off and speculate about what TiddlyChatter could be used for. Here's a couple of ideas:

core functionality in TiddlyWiki - "let your TiddlyWikis IM each other"
discussion area for blogs - tag a blog post with "public" and you can treat the blog RSS feed as a ChatterFeed

Add your ideas as notes and I'll update this tiddler with them as we go along

ChatterFeedYourName

YourName — Fri, 02 Nov 2007 16:15:00 GMT

Type:	RSS
URL:	http://fnd.tiddlyspot.com/
Workspace:
TiddlerFilter:	[tag[public]]

ChatterFeedjayfresh

jayfresh — Fri, 02 Nov 2007 16:15:00 GMT

Type:	RSS
URL:	http://jayfresh.tiddlyspot.com/index.xml
Workspace:
TiddlerFilter:	[tag[public]]