My software is more or less like Cthulhu. Normally dead and at the bottom of the sea, but occasionally stirring and throwing out a languid tentacle to drive men’s minds insane. (Or at least perturb a couple of more recklessly adventurous users.)

However there’s been a bit more bubbling agitation down in R’lyeh recently. The latest weird dream returning to trouble the world is GeekWeaver, the outline based templating language I wrote several years ago.

GeekWeaver was basically driven by two things : my interest in the OPML Editor outliner, and a need I had to create flat HTML file documentation. While the idea was strong, after the basic draft was released, it languished. 

Partly because I shifted from Windows to Linux where the OPML Editor just wasn’t such a pleasurable experience. Partly because GW’s strength is really in having a templating language when you don’t have a web server; but I moved on to doing a lot of web-server based projects where that wasn’t an issue. And partly, it got led astray – spiralling way out of control – by my desire to recreate the more sophisticated aspects of Lisp, with all kinds of closures, macros, recursion etc.

I ended up assuming that the whole enterprise had got horribly crufty and complicated and was an evolutionary dead end.

But suddenly it’s 2013, I went to have quick look at GeekWeaver, and I really think it’s worth taking seriously again.

Here are the three reasons why GeekWeaver is very much back in 2013 :

Fargo

Most obviously, Dave Winer has also been doing a refresh of his whole outlining vision with the excellent browser-based Fargo editor. Fargo is an up-to-date, no-comprise, easy to use online OPML Editor. But particularly important, it uses Dropbox to sync. outlines with your local file-system. That makes it practical to install GeekWeaver on your machine and compile outlines that you work on in Fargo.

I typically create a working directory on my machine with a symbolic link to the OPML file which is in the Fargo subdirectory in Dropbox and the fact that the editor is remote is hardly noticable (maybe a couple of seconds lag between finishing an edit and being able to compile it).

GitHub

What did we do before GitHub? Faffed, that’s what. I tried to put GeekWeaver into a Python Egg or something, but it was complicated and full of confusing layers of directory.  And you need a certain understanding of Python arcana to handle it right. In contrast, everyone uses Git and GitHub these days. Installing and playing on your machine is easier. Updates are more visible.

GeekWeaver is now on GitHub
. And as you can see from the quickstart guide on that page, you can be up and running by copying and pasting 4 instructions to your Linux terminal. (Should work on Mac too.) Getting into editing outlines with Fargo (or the OPML Editor still works fine) is a bit more complicated, but not that hard. (See above.)

Markdown

Originally GeekWeaver was conceived as using the same UseMod derived wiki-markup that I used in SdiDesk (and now Project ThoughtStorms for Smallest Federated Wiki). Then part of the Lisp purism got to me and I decided that such things should be implementable in the language, not hardwired, and so started removing them. 

The result was, while GeekWeaver was always better than hand-crafting HTML, it was still, basically hand-crafting HTML, and maybe a lot less convenient that using your favourite editor with built-in snippets or auto-complete.

In 2013 I accepted the inevitable. Markdown is one of the dominant wiki-like markup languages. There’s a handy Python library for it which is a single, install away. And Winer’s Fargo / Trex ecosystem already uses it. 


So in the last couple of days I managed to incorporate a &&markdown mode into GeekWeaver pretty easily. There are a couple of issues to resolve, mainly because of collisions between Markdown and other bits of GeekWeaver markup, but I’m now willing to change GeekWeaver to make Markdown work. It’s obvious that even in its half-working state, Markdown is a big win that makes it a lot easier to write a bigger chunks of text in GeekWeaver. And, given that generating static documentation was GeekWeaver’s original and most-common use-case, that’s crucial.

Where Next?


Simplification. I’m cleaning out the cruft, throwing out the convoluted and buggy attempts to make higer-order blocks and lexical closures. (For the meantime.) 
  
Throwing out some of my own idiosyncratic markup to simplify HTML forms, PHP and javascript. Instead GW is going to refocus on being a great tool for adding user-defined re-usable abstractions to a) Markdown and b) any other text file.

In recent years I’ve done other libraries for code-generation. For example, Gates of Dawn is Python for generating synthesizers as PureData files. (BTW : I cleaned up that code-base a bit, recently, too.)

Could you generate synths from GeekWeaver? Sure you could. It doesn’t really help though, but I’ve learned some interesting patterns from Gates of Dawn, that may find their way into GW.

Code Generation has an ambiguous reputation. It can be useful and can be more trouble than it’s worth. But if you’re inclined to think using outlining AND you believe in code-gen then GeekWeaver is aiming to become the perfect tool for you.

There’s a lot of discussion going on around them. Eg. on Quora.

I started writing a comment on a comment where Tim Bushell asks :

why shouldn’t they be “red”, “green”, “blue”?

ie. user-defined or neutral.

But then felt it would be better here :

Probably because Google have a database of thousands of email addresses and patterns that they’ve classified into these categories of “social”, “promotion” etc., and with this move they’re basically giving you, the customer, the benefit of that classification scheme.

They assume that if you just want to program your own categories and sort accordingly you’re already doing it via filters.

What probably didn’t occur to Google was that the world is full of people who WANT to be able to define their own categories and filters but never realized that GMail (like every email client in the 20+ years) already HAS this feature.

What’s happening is that just by showing people tabbed email, they’ve suddenly woken everyone up to the fact that your email client can be programmed to filter emails. (Who knew?)

What happens now is going to be interesting.

If Google know how to listen, they’ll take advantage of it, add the ability to define your own tabs, integrate it seemlessly with the existing filter architecture of GMail (maybe improve the UI of that a bit, eg. drag / dropping between tabs) and get to bask in the adoration of having “reinvented email”.

If not, they’ll keep the two systems separate (ie. filter-definition hidden away where most people can’t find or understand it) and not only will the opportunity be squandered, but many people will continue to hate the tabs.

Thanks to Bill Seitz I picked up on a Giles Bowkett post I’d missed a couple of months ago which compares the loosely coupled asynchronous style of development that companies like GitHub both promote and live, with the intensely coupled synchronous raids that occur in online game-worlds.

Bowkett seems confused by the apparent contradictions between the two. And yet obviously impressed by the success of both. He wants to know what the correct synthesis is.

That really shouldn’t be so hard to imagine. The intense coupling is what happens in pair-programming, for example. Or the hackday or sprint. Its focus is on creating a single minimum product or adding a single feature / story to it.

The right synthesis, to my way of thinking, is intense / tight / adrenalin fuelled / synchronous coupling over short periods, where certain combinations of talents (or even just two-pairs of eyes) are necessary. And loose / asynchronous coupling everywhere else. Without trying to squash everyone’s work into some kind of larger structure which looks neat but doesn’t actually serve a purpose.

The future of work is highly bursty!

It shouldn’t surprise us, because modularity is one of the oldest ideas in software : tight-cohesion within modules of closely related activities. Loose and flexible coupling between modules. It’s just that with these work-patterns we’re talking about modules in time. But the principle is the same. The sprint is the module focused on a single story. The wider web of loosely asynchronous forks and merges is the coupling between modules.

I love Quora. It’s a great site and community. But I started getting a bit concerned how much writing I was doing there which was (potentially) disappearing inside their garden and not part of the body of thinking I’m building up on ThoughtStorms (or even my blogs).

Fortunately, I discovered Quora has an RSS feed of my answers, so I can save them to my local machine. (At some point I’ll think about how to integrate them into ThoughtStorms; should I just make a page for each one?)

Anyway here’s the script (powered by a lot of Python batteries.)

And this turns the files back into a handy HTML page.

Today I’m being driven crazy trying to print out FiloFax pages on an HP printer.

Although I’ve created a PDF file of the right size, I have the right size piece of paper, and I’ve set up the paper-size in the print-driver, the printer is refusing to print because it detects a “paper size mismatch”.

A quick look through HP’s site reveals a world of pain created by this size-checking-sensor which can’t be over-ridden. People are justifiably pissed off.

What’s striking is that this is a problem that didn’t exist previously. There are many accounts in this forum of people who, on their older printers, happily used incorrect page-size settings in the driver, with odd-sized paper, and just got their job done.

HP by trying to add “smartness” to their product have made it less usable. This is such a common anti-pattern, engineers should be taught it in school : the more smart-constraints you add to a product, the more likely you are going to disempower and piss-off the edge-cases and non-standard users.

Recently I wrote a Quora answer which I brought to ThoughtStorms : MachineGatekeepers . I worried for people who didn’t know how to navigate technological problems in a world where we’re encaged by technology.

But I have an even greater worry. The road to hell is paved with “helpful constraints” added by idiots. And we’re all suffering as technologies which, with a pinch of know-how or intuition we could bend to our will, become iron cages. It’s no good knowing how to google the FAQ or engage with tech. support when HP support is effectively non-existent.

The most disturbing thought here is that BigTech knows this, and increasingly takes away our freedom with one hand and sells it back to us on the other. If enough people complain that their HP won’t print on FiloFax pages what’s the most likely result? That HP release a fix to disable the page-size-sensor? Or that they’ll just release a new printer model which also handles FiloFax paper but is otherwise equally restricted?

I’m a couple of days into LinkBlogging using Fargo, (at Yelling At Strangers From The Sky) and I have to say, I’m getting into the swing and it’s great.

If you keep the outline open in a tab, it’s about as fast and convenient to post to Fargo as posting a link to Plus or Twitter. (Which is where traditional blogs like WordPress / Blogger often fall short). In fact, G+ is now getting bloated that it can take 10 seconds just to open the “paste a new message” box. It’s a lot faster than that.

It would be nice if it could automatically include a picture or chunk of text from the original page the way FB / G+ do, that’s turned out to be a compelling experience for me, but it’s a nice not must-have.

A question, is there any kind of API for the outline inside the page which a bookmarklet could engage with? (Is that even possible given the browser security model?)

Couple of quick notes :

1) I’m too dependent on Google. Unlike the case of Facebook, I can’t just cancel my account. Google is too deeply entwined with my life. But I am taking steps to disengage if not 100% at least a significant chunk.

2) I’m playing around a bit more with Dave Winer’s Fargo outliner. And it is shaping up to be excellent, both as an outliner and expression of Winer’s philosophy. (No surprises.)

So, to combine the two, I’m documenting my Google-leaving thoughts in a public outline. Check it out.

Update : I’ve also been wondering about having a linkblog, somewhere I can quickly throw links rather than G+ (which is inside the Google Walled River). Maybe Fargo will help there too.