Subversive Heresy

I've tried various source control systems: clearcase, subversion and svk. Received software development wisdom says you *must* use a source control system. Why? Well here are some of the purported advantages:

• you can rewind the tape
• you can hack simultaneously
  
• you can branch
• you can browse (e.g., SVN::Web)
• you can blame

But in practice I rarely find myself rewinding the tape - my editor does that, and in the worst case scenario I can get the original file from production or staging. The retrieval cost of 'rewinding the tape' from the repository to a specific version is often higher than coding afresh (which version was that again?).

Simultaneous hacking on the same file in a huge code base happens infrequently but when it does resolving clashing files is a pain. The "blame game" is also pretty pointless. Mentally managing commits adds an unnecessary cognitive tax and takes time too. I don't know about you but I get a feeling of "repository drag"?

Ideally the software scaffold should not slow you down - but speed you up! I wonder if there is a better way? Fast browsing, no more commit overhead, clash prevention, automatic change logging and easy history traversal ...

Measuring Future Events

It is a goal of The Goo to help you stick Things together - now - but in the future too.

The ability to reason about the future depends on reasoning clearly about events that might, or might not happen, and their relative importance.

A recent O'Reilly book, "Mind Performance Hacks" suggests an interesting way of measuring the importance of something in the future. Paraphrasing loosely from the book it combines two Likert scales (1-7):

Likelihood of event happening:

Never                   Likely                          Certain
1         2         3         4         5         6         7

Importance/Impact of event

Not Important           Somewhat Important              Very Important
1         2         3         4         5         6         7

By combining the two scales you get a value out of 49 - and by doubling it a value roughly out of 100!

This simple heuristic gives you a measure of relative future importance. Why worry about something if it is never going to happen? On the other hand something may seem relatively unimportant yet it is certain to occur.

Stay tuned for how future events will find their way into the Care-o-Meter via this simple measure.

New Action Dispatcher - Targeting Things

The Goo has a new action dispatcher that does type-based dispatch. The action handler is chosen based on the type of Thing and it works from the web and the shell:

http://goo.localhost/r?arg1=tn7rc
shell> goo r tn7rc
shell> goo resolve tn7rc
shell> goo p HelloWorld.pm
http://goo.localhost/profile?arg1=HelloWorld.pm

But there are at least two other environments where I want to do actions on Things: email and while editing. Previously I mentioned the idea of ThereDOCs (e.g., p>>) - a way of embedding removable commands into text that help you context switch. Although there is a nice symmetry between Perl's HereDOCs <<>> - the ">>" characters are overloaded in the context of email (e.g., >> forwarding quotes) and Perl6 (i.e., hyperoperator).

So the new ThereDOCs (i.e., embedded action character sequence) will look like this: ~> and <~. The dispatcher must analyse the target of the action for 'Things' and based on type do the dispatch.

# imaging you're editing some code
use Hello::World; <~t # you want to jump to the tests for this module
use Template::Simple; <~p # you want to profile this module

# use Uri Guttman's sublime Template::Simple
Template::Simple->new->render("complicated.tpl", $tokens); <~p # jump to the profile of complicated.tpl

My::Logger::write("/tmp/look.log", $message); <~t # jump to the tail of look.log

When it comes to email I should be able to resolve a task by forwarding an embedded action to goo@somedomain.com. For example,

To: nigel@turbo10.com
CC: goo@somedomain.com
Subject: resolve~> tn5rc

Because all actions go via the Dispatcher it is also a natural place for remembering the trail of actions.

Mnemonic Thing IDs

I've just moved to mnemonic Thing IDs. Thing ID 15466, for example, has now become, tn6rc.

Why? Well mnemonics are one way we can do cognitive compression/chunking. But also because ...

• The ID itself carries meaning (e.g., tn6rc = Trexy task given to Nigel with care factor 6 Restart Cluster).
• Automatically finding Things IDs in emails, web pages, databases, logs etc. based purely on numbers can be ambiguous.
• Prefixing numeric Thing IDs with a hash # causes the Thing ID to be commented out in the bash shell and can also appear as anchors in URLs - making automatic Thing finding trickier.
  

Mnemonic IDs look more at home in a 70's airline booking system but I think they're due a comeback - TMTOWTDI - but that's also the point.