[tpm] Thanks for attending my git flow presentation

[Alex Beamish]

Hi folks,

I appreciate the turnout last night for my still-somewhat-uncooked
presentation on git flow. The questions and tangents stretched a five
minute presentation into almost an hour, which was good -- it would
have been disappointing to be done by 715pm.

Using git flow (and discussing it with you last night) makes me better
appreciate their model, which I'll reiterate.

[] Most of the action happens from Development, but not actually *on*
Development; features and bug fixes launch themselves from that branch
(git flow feature start addPOD, in my case) and, in time, resolve back
into Development (git flow feature finish addPOD).
[] When Development is sufficiently advanced, a version is moved to
the Release branch (git flow release start 0.1) and tested out. There
may be some commits from there as the release is fine-tuned.
[] When the Release is sufficiently beautiful, it's released to Master
(git flow release finish 0.1).
[] If a Hotfix to a Release is required, that's done *from* the Master
branch, but again, not actually *on* that branch.

I also appreciated the discussion around setting up a git server, and
I was glad to see that I wasn't the only one who tried to push an
empty local repo to the remote server and get an error. In hindsight,
of course, it makes sense, but at the time it was a little disturbing.
The more I try things out with these tools, the more comfortable I'll
be.


The 'test project' that I worked on when preparing for this
presentation is a version of runoff, using
http://plan9.bell-labs.com/sys/doc/troff.pdf as a reference. I come by
this fascination quite naturally -- I worked on the student newspaper
at Waterloo (the chevron, and later, the free chevron) during my first
year ('76-'77), where I worked under Neil Docherty, the Production
Manager, from whom I learned all about newspaper production. My work
terms were spent with AES Data in Montreal, working on a standalone
word processor system ('77-'80). A few years after I graduated, I
worked in the nascent desktop publishing field for a company called
Laser Friendly (long gone), owned by Print Three Franchising (they're
still around), on their product called The Office Publisher ('87-'90).
So writing something that flows text into columns goes back a long way
for me.

As I briefly explained, the concept I wanted to follow was based on
the object of a Document that consists of a series of Pages; each Page
consists of a series of Blocks (definition TBA -- may morph into
Columns, but I'd also want to handle Tables); and each Block contains
a series of Lines. Each line of a runoff file is passed into a
Document, which either deals with it locally or passes it down to the
next layer. Each layer has its own settings that are independent of
the other layers.

This object model, like my presentation, is a little uncooked -- but I
don't want to firm it up too much, in order to be able to handle
things like two column layouts, footnotes, balanced columns and so
forth. If there's any interest in this implementation, please let me
know. (I've had a PAUSE id for years -- it would be nice to finally
use it.)

Cheers,
Alex Beamish