The Goo Trail

At the core of The Goo is a "trail". A trail is the path you leave behind when you traverse Things in your programming environment. The idea of a trail is inspired by the "Memex" (a device conceived in 1945 by Vannevar Bush). This was also the inspiration behind Trexy a trailblazing search engine.

Every action you take while using The Goo is stored in a trail. But why is this useful?
The Goo trail:

• stores temporal associations between Things.
• helps answer the question, what else was I working on when I last accessed this Thing?
• provides a working context of Things that you are currently juggling. Your current mental working 'zone' is the tail of the trail.
• preserves your programming memory for later retrieval by yourself or others
  

The Goo Prerequisites

At the moment The Goo relies on a few prerequisites to work:

• MySQL database (for sharing database Things with others)
• SQLite (for client-side GooTrail recording)
• Linux

and the following Perl modules:

• Text::FormatTable
• DBI::PurePerl
• DBD::DBM
• DBD::ExampleP
• DBD::File
• DBD::NullP
• DBD::SQLite
• DBD::Sponge
• DBD::mysql
• DBD::mysql::GetInfo
  
• DBI
• Term::ReadKey
• Term::Complete
• Text::FormatTable
• Term::ANSIColor

The Goo also uses PerlTidy to automatically tidy your Perl code. A syntax highlighting text editor should also be present (e.g., vi, nano, emacs etc).

Help packing up The Goo (CC the Blog)

Hi,

Thanks for accepting the challenge of packing up The Goo for an alpha release!

Here's what to expect:

The Goo is a system for sticking Things together in your programming environment.

The Goo assumes that all "Things" have a unique filename suffix. Some of the Things that The Goo can stick together in the alpha release will include: perl modules (.pm). perl scripts (.pl), perl tests (.tpm), text templates (.tpl), configuration files (.conf), log files (.log) etc. There are also database Things and these too are named with a suffix. For example, "121.bug" referers to bugid 121 in the bug table.

Each type of Thing has a corresponding Goo configuration file based on its filename suffix. For example, the perl modules (.pm) config file is called "pm.goo" and the perl script (.pl) config file is called "pl.goo". The Goo itself has a top level config file: "goo.goo" and all config files are found in the same directory: ./goo/things/goo. Here is an example Goo config file.

Each config file contains a set of actions that can be performed on the Thing. For example, some of the actions that can be performed on a perl module (.pm) include:

title = Perl5 Module
filename = pm.goo
suffix = pm
description = Perl modules
[M]ake = ModuleMaker
[E]dit = ProgramEditor
[P]rofile = ProgramProfiler
[D]elete = ProgramDeleter

Any letter included in square brackets becomes a command line option. For example, the command "goo -e Example.pm" (i.e., [E]) will invoke ProgramEditor.pm to edit the module, Example.pm.

To install this first version of The Goo unpack the tar file and edit the .goo configuration files in /goo/things/ to point to the file locations in your system. This will give you a starting point to do the code review. Type goo -p to profile a Thing. This should get you started. Good luck ...

Nige

Packing up The Goo

I've submitted a talk to the London Perl Workshop on The Goo. I won't know if it's been accepted for another week or so but either way it's a good excuse to start publishing the code behind The Goo and getting it ready to be shared.

This is an early alpha version - so expect bugs.

An expert Perl programmer from PetaMem is going to help me pack it up and ready it for very early alpha release. There's lots to be done. I'm going to share some of our correspondence on the blog to help provide some background to this very first release.

Care-O-Meter Version 2

Well version 1 of the Care-O-Meter worked and gave me a glimpse into how my productivity can skyrocket. It has forced me to stay on the case and focus on what I *really* need to be doing. This is helping but changes are needed already. The first problem is there is too much information coming through. The Care-O-Meter is listing too many incoming tasks and bugs. The number one design objective of The Goo is to help manage cognitive load:

Seven Bugs + Seven Tasks = Buffer Blowout

So this is going to change.

But then comes the next questions: how many tasks? bugs? which bug is more worthy? why? The importance rank helps, but ultimately I want to choose to do what I 'feel' like doing. The Care-O-Meter should act as a guide not a task master. This is where the 'emotional' part comes in. What do you *feel* like doing next? Stay tuned for Care-O-Meter version 2 ...

The Care-O-Meter - Version 1

The Care-O-Meter is a ranked queue of Things I care about while coding. Have you found yourself finishing a batch of work and then thinking "what should I do next?" The Care-O-Meter answers this question. For version 1 it shows a ranked list of tasks and bugs. You only see the top three most important tasks and the top four bugs - never more than seven total Things at a time. This means when you finish a task you can quickly context switch to the next task - without slowing down to work out what to do next. The task and bug descriptions are scanned for "Things" so they are automatically associated with the software. This means you can jump quickly to the Thing(s) that the task (or bug) relates too.

But tasks and bugs are just two examples of the Things a programmer needs to care about .... stay tuned for more Things handled by the Care-O-Meter ....

The Emotional Programmer

How's that for an oxymoron?

But if I'm trying to model how the programmer copes with context switching and cognitive load - shouldn't I consider other mental activities? Like emotional stuff too? During the process of programming I can get happy, sad, frustrated and even excited - just to name a few emotions. Contrary to the stereotype, programmers aren't code cutting automatons without any heart - we've got feelings too! ;-)

Perl programmers, for example, have even been known to write 'poetic' programs. So what about the emotional side of programming? I haven't heard of an IDE that helps the 'emotional' programmer - I wonder if The Goo can help me out here? Why not.

Injecting emotional artefacts into the 'trail' can help recall. That's how I 'felt' when I was last dealing with that part of the system. It will also help ordering artefacts in the "Care-o-Meter".

"The Zone"

The zone is your working mental buffer. It's what you're currently juggling. At most we can juggle 7 plus or minus 2 things at a time. The Goo tries to make coding easier and quicker by throttling your mental buffer. It does this by keeping you in the productive "zone" while minimising the cost of context switching. It maintains a trail of all the actions you do. The Zone is the 'tail' of this trail.