Deliberate Thinking

Awesome CLI gem: Commandable

2012-01-10T07:46:00.001-07:00

Ever wanted to drive your ruby code with a CLI? Well, the commandable gem makes it easy.

At first, I struggled with OptionParser in the stdlib, but I had to duplicate my option handling across CLI code and method invocation. Then OptionParser didn't handle required parameters at all, requiring me to do required parameters in a non-DRY way. Also, OptionParse doesn't do sub-commands, git-style, which I needed for the new git plugin I'm working on.

When I saw the pickled_optparse gem (from Mike Bethany), it appeared to solve the missing 'required parameter' feature. And the subcommand gem seemed to allow for subcommands with their own options, git-style. However, the duplication across option definition and method invocation was still present. And even subcommand required you to hook up the command to the class/method that needed to be called.

Finally I found that the author of pickled_optparse had totally rethought CLI in ruby with his commandable gem. And I really like what he did.

Now there is no real additional logic AT ALL in order to hook your ruby class up to the command line. Now my option handling code will be in the place it belongs, in the code that is doing the command that I invoked from the command line.

The main awesomeness here is that commandable pushes the CLI code into the appropriate place in your ruby class -- it makes it hard to scatter CLI code all over the place.

My only beef with the gem are the following points:

it comes with colors enabled by default (unusual for a CLI)
it clears the screen by default when displaying help (when colors are enabled, very unusual and annoying for a CLI)
it appears to be hard to do global options like: "cmd --global subcommand [args]"
there is no support for parsing command CLI-style options into ruby hashes, but this is a minor nit, because that's what OptionParser is for, and it's easy to use inside the method

I fixed a problem where the screen was cleared even if you disabled colors, and I've pushed it up to my fork.

Here is my hello world that shows commandable in action:

And here's the output for a few representative cases:

Open Genealogy Alliance

2012-01-04T22:37:00.002-07:00

The manifesto posted at opengenalliance.org is something that I can very much support.

As part of RootsTech 2012, I'm going to sign up for an open hour to talk about open content licenses. Anyone who has an interest in this topic, please get in touch with me and we can collaborate on the presentation.

I wonder what it will take to get some more visible & material signs of support from archives, libraries, societies, museums, or genealogical content companies on that site.

Something like the contributors listed on opencontentalliance.org.

Perhaps a link to the Better Than Free article is in order. My personal resources are small, but if there is any kind of material support I can give to the opengenalliance.org effort, I want to do so.

Here are a few examples I could find of license information on open content sites (some related to genealogy, some not):

Wish TwitterFeed supported auto-hashtags

2012-01-03T10:49:00.002-07:00

After using TwitterFeed for a while, it's really cool! Props to betaworks for an awesome tool!

All I want now is auto-hashtag support.

Just look for the last line of a post that is only hashtags, and #dont #take #arbitrary hashtags from the #body of the #post.

Don't bother with trying to convert blog post tags into hashtags -- I want a different vocabulary of hashtags on twitter vs. tags on my blog.

#twfeed #hashtags

Open Geneological Research Vision

2012-01-02T12:49:00.005-07:00

At its core, every sustained genealogical research effort turns into a global, loosely-connected, semi-structured distributed edits problem.

Open genealogical research needs a few conditions to thrive, I think.

significant stable corpus of research
everyone publishing under compatible open data licenses (CC-BY[-SA], CC0, or others)
agreed-upon standard data formats
ability to self-publish and curate your own research, independent of anyone else
ability to make corrections, and publish those corrections, independent of anyone else
ability to follow others' self-published research/corrections and pull it into your own research if you agree
mechanisms that encourage convergence of separate research efforts on the same research topics

Significant advances have been made in the last decade to enable certain aspects of online genealogical research. The contributions of Ancestry and FamilySearch to providing indexed original records should not be underestimated.

The global family tree databases of Ancestry, Geni, FamilySearch, One Great Family, and others are also very significant. The efforts of TNG and PHPgedview are especially significant in the control and latitude that they give to individual contributors in their efforts to self-publish.

However, online is not the same as open. Open means more than just letting the general public search or get a login, it means that the dataset is licensed under an open license, and that this open licensing is adequately encouraged for subsequent contributions.

The ability for collaborative self-publishing is a primary concern that seems only partially implemented at this point in existing tools.

I have had this picture in my head for a while, and it seems the right time to start writing about it and doing something about it.

Seen, Persuaded, Embraced, Confessed

2012-01-02T12:13:00.000-07:00

One verse in Paul's description of the fathers of faith stood out to me:

Heb. 11:13 These all died in faith, not having received the promises, but having seen them afar off, and were persuaded of them, and embraced them, and confessed that they were strangers and pilgrims on the earth.

I've watched true followers of Jesus Christ demonstrate their devotion to Him in ways that involve all four elements of conversion. In fact, I'd be willing to take this verse as a starting point for describing what true conversion is like.

It seems to me that this pattern of increasing commitment and devotion is tightly involved in the process of understanding what one's personal mission in this life is. When it finally gels, there isn't anything else but just to go do your life's work, and give your whole self for your Lord Jesus Christ and what He's called you to do here.

Useful Git Tips

2011-12-31T10:24:00.001-07:00

Every one of these tips was useful to me:

http://mislav.uniqpath.com/2010/07/git-tips/

It just amazed me that these were written over a year ago, and I've been trying to learn as much about git as I could, but didn't even stumble across these in manpages.

I found this by looking for an option that would let "git remote update" only fetch a subset of the remotes I have attached.

It is rewarding to feel like I'm working with a rich toolset.

Thanks to @mislav for posting this.

BTW: Poking around in his tweet stream also yielded this gem. I've always wondered if there was a lightweight XPath for JSON, and there it is. Some background is in order, as much of the "XPath for Javascript" mentality was based on early JQuery thoughts.

Subscribing to FamilySearch Updates

2011-12-31T08:29:00.001-07:00

Keeping up with all that's going on at FamilySearch is harder than it needs to be, but I finally figured out how.

Most sites give you large categories of feeds to track, but FamilySearch has all of 14 different feeds, some of which overlap or not (the feeds are available by appending '/feed' to the URL). But I couldn't find any "everything" feed URL.

Because I work for FamilySearch, and because I care about what goes on around me, I want to subscribe to everything, if only just to skim. The most important announcements get forwarded through internal email, however the additional articles are very useful context, especially for an employee.

Unfortunately, the default "subscribe" link just subscribes you to feeds #2, #3, & #4, or Indexing, Record Search, & Indexing, respectively. The "Subscribe" link is visible on an individual article's page, but isn't even present on the main blog page.

Here is the feed link you can put in your feed reader to subscribe to everything:

https://www.familysearch.org/taxonomy/term/1+2+3+4+5+6+7+8+9+10+11+12+13+14/0/feed

When feed/category/blog #15 gets defined, this feed URL will be invalid again. Maybe there is a better way. If anyone knows a better way, please let me know.

I want an "everything" subscribe link that I won't have to update in my feed reader, or maybe an "everything but trivia" link.

Missed Tweets Through News.me

2011-12-24T09:55:00.001-07:00

I've never really been a twitter nut. There are already enough sources of distraction for me, I don't need to add another source. It just seemed really noisy.

However, people have been saying and linking to important things on twitter for a while now. I'm just not discerning enough and don't have enough time to filter the firehose in a useful way.

The most helpful summary of interesting news I skim regularly is the weekly LinkedIn emails. In fact, I think it may have been through a link chain from one of those emails that I stumbled on unionfs, as reported in the last post. If I could have the same thing for twitter, but personalized to the people I follow, that would be really helpful!

Ironically, as part of the effort to make this blog more stuble-upon-able, I was looking for a way to auto-post on twitter and facebook whenever I post on this blog, and I found twitterfeed.com, which does all of that and more. And it's easy to set up.

After setting that up this morning, I wondered: "What is the company behind twitterfeed.com?", and found betaworks. They run some very interesting sites/companies, some of which I knew about (bit.ly), some of which were new to me (findings.com, chartbeat.com). The interesting one for me right now was another site called news.me.

Turns out that news.me is just the kind of thing that has the chance of making twitter useful to me. If things go well, you'll probably hear more about it.

Intrusion Detection through Stackable Filesystems

2011-12-21T15:08:00.001-07:00

I've always wondered what exploit might be running on my system, and never had any time to devise/install a detection system that would have the right balance of useful detection (maximize) and performance impact (minimize).

When I stumbled upon unionfs a couple weeks ago, I thought that was an interesting idea from a change-logging perspective. It's sometimes useful to be able to keep a filesystem-based diff of what a certain operation does to a system, and then bake it onto the system when I know it did what I wanted to. The takeaway for me was that unionfs's performance profile had the opportunity to be so low because it was so thin and so baked into the kernel.

This compounded with my recent discovery and fiddling with fusefs (in user-land) and I wondered about what kind of useful logic I could put underneath a filesystem. The GlusterFS feature set, the recent LessFS GC stuff, the bup-fuse stuff, and the S3FS stuff is all just *really* cool. I ended up gazing longingly at the big backlog of fuse filsystem suggestions on their wiki, and wandered back into the unionfs space.

So, when I saw the I3FS paper (linked from here) about the modular application of this technique to intrusion detection, this really triggered the Useful *AND* Performant neurons and I got really excited.

Unfortunately, on first glance, the stackable filesystems stuff seemed pretty cryptic to set up in a lightweight, just-works kind of way (think custom mount command-lines complete with arcane stacking options).

It would be soooo awesome to have an easy-to-compose ruby DSL for doing some kind of rack-like filesystem mashup with a kernel-level unionfs layer underneath a user-land fusefs layer, but all expressed in the same DSL.

This would be an awesome tool to put on top of the Arch-derived clone I want to put up for people at work. There are folks who care about living more on the edge of linux stuff, but that don't care to install from scratch, and also might not care that much about not having a full Gnome stack if things just work. And if I could give them the same tuned IDS-on-the-desktop solution (or upgrade their developer stack by letting them pull a filesystem delta over), that would be really cool.

The cheap development observation [PDF, linked from] because of modularity is one of attributes valued highly by the Ruby community as well. It is one the key things that makes Ruby as a community awesome.

These kinds of ideas really matter, and making them so cheap and stable that you don't have to think about them really matters even more.

NOTE: The I3FS paper is really pretty old (2004), and the whole unionfs stack is older than that. The fuse stack came into the kernel a long time ago too (2005). So while this is new to me, it's been around for quite a long time. I'm playing catch-up.

Unicode Support Better Now in Ruby

2011-12-21T08:46:00.001-07:00

Unicode support in Ruby has historically been one of Ruby's major problems for me.

With the advent of Ruby 1.9 of course, Unicode support started being added to the language. However, it's not as straightforward as Java, which supported some version of Unicode from the beginning.

Even though it's been a rough decade, things are finally looking up. In fact, I actually like the way things got factored after all of the mess.

The thing I like is that the minimal amount of support is included in the standard library, and it's easy to compose things in non-standard ways for weird scenarios or data in improperly encoded formats.

The core library has support for strings of codepoints and bytes and a flexible set of encoding facilities.

In addition, there are two libraries of interest:

unicode_utils - includes implementations of word-break functionality, grapheme boundaries, etc.
jcode (if you're stuck on ruby 1.8.x)

This series of posts gives you a full understanding of the topic. Highly recommended!

This post gives a high-level view of where things were at around 2006, much of which is valuable background.

This post has a good summary of unicode-related resources, as does this stackoverflow question.

Semantic Versioning

2011-12-21T07:56:00.003-07:00

After having skimmed the semantic versioning proposal/spec, I really like it, and I'm going back for a deep read.

The most notable violator of this that has bit me in the past has been the jersey framework, and maybe earlier versions of commons-collections.

Some Git/Ruby stuff of interest

2011-12-19T08:27:00.001-07:00

While taking the git survey a while back, I encountered:

git-annex: awesome git-enabled large file archive support

which led me to:

git-bup: way cool! git-like backup, even serves as a remote for git-annex

also this morning ran into:

rib: irb, except better, including rib-heroku
rest-core: like rack, except for RESTful clients
gemgem: easy gem building, without all the hoe dependency cruft

I just wish that gem-man read the README{,.md} in the root of a gem (like gemgem does) if that gem didn't have a manpage. Sounds like a good patch to send. That will help me understand how gems can access their own filesystem post-install.

Thought you might like to know.

And btw, rbenv is way nicer to interact with than rvm, at least that's been my experience over the last couple weeks.

srev-taming: Migrating Subversion to Git

2011-12-15T09:22:00.002-07:00

After reading about Mediawiki's pending svn => git migration, it sounded very familiar to me, because I was proposing such a conversion at work about a year ago.

Mass svn => git migration tooling doesn't really exist in the way I wish.

The most popular tool is probably svn2git. But even with all the conversion goodies baked into it, it's still based on git-svn.

Anything based on git-svn means that for an svn repo that has multiple projects in it, you have to take N passes over the repository, which is a huge hit for repos in the 20,000+ commit range.

The most performant conversion tool is svn-fe, but it doesn't do much more than just import at the repo boundary: 1 svn repo => 1 git repo. And it doesn't even begin to deal with the situation of multiple svn histories as we have migrated from one repo to another.

The closest thing that exists is a set of scripts posted as part of this thread.

Here is a rough cut of a project I wish existed:

"srev-taming" ~~ "svn-migrate"
(anagram, in the spirit of "snerp-vortex" ~~ "svn-exporter")

scan of SVN dump for projects & codelines => annotated projects & branches list
easy invocation of svn-fe for mass-import => generate me a command-line
editable auto-detected project tags & codelines => language that easily expresses projects, codelines & grafts
easy clone/filter-branch invocation to extract & stitch codelines together (based on projects & branches list and configured grafts)
post-import filter for author fixup, SVN & migration artifact removal => generation of starting author list & svn URL minifier

Unless I get explicitly assigned to do the migration, I guess it's not going to prioritize high enough for me to do anything about it. At least svn-fe is being maintained and enhanced.

But I'm posting it here to see if anything exists that I don't know about -- or in case it sparks some ideas for someone to create this thing.

Backwards Names

2011-10-29T21:58:00.000-06:00

My family likes to play a fun game called Backwards Names. This game is played by taking each name piece of a person's name and reversing the characters and trying to pronounce it fluently.

I was just sitting on the couch tonight after a long Saturday and not thinking about backwards names at all. I had my laptop open to get some work done, but my son sat down next to me, and I wanted to show him some programming.

I started out in irb and just did some simple string substitution with his name, but irb and ruby make it so easy to just mess around that I ended up with an implementation of Backwards Names before I knew it.

Here it is:

It was just really fun to do that with him and see lights start to turn on about what programming was like.

Git as Menograph

2011-10-19T12:40:00.003-06:00

Background

In Mar. 2010, Matz came and talked at MWRC.

The awesome talk focused around Ruby as a great invention that makes it possible for programmers to bring a new world into being that could only be imagined before.

He made reference to the inventor in Hugo Gernsback's book: Ralph 124c 41 +. The name was a play on words "One to foresee for one", with "+" being reserved for the 10 or so greatest inventors currently living.

Although Matz's reference could be interpreted as prideful, anyone who has ever had anything to do with him would correct you -- he is a very humble programmer who does awesome stuff.

Because I wanted to understand Matz's reference very thoroughly, I went and read the book. I was able to appreciate the scope of Matz's talk much more clearly after having read about Ralph, the great inventor.

Menograph, the invention

One thing that Ralph invented was a Menograph. It was a mind-recording device, operated by pressing a button that started a mind wave recorder and operated a scroll of fabric on which the waves were traced in ink, similar to an old-style seismograph.

The Menograph was one of Ralph 124C 41 +'s earliest inventions, and entirely superseded the pen and pencil. It was only necessary to press the button when an idea was to be recorded and to release the button when one merely reflected and did not wish the thought-words recorded.

Those thoughts could then be replayed again verbatim by any person by use of a device called a Hypnobioscope.

After reading an account of Ralph using this invention, which is more detailed than I am able to reproduce here, I had a vague sense that I had experienced a similar feeling before while programming.

Git as Menograph

After thinking about it for a while, I realized that how Ralph used his Menograph is how I use git.

While coding, I work on stuff, then I record commits into git. Then I work on stuff some more, then record commits.

Then I take passes back over what I've recorded and get rid of the bad stuff and keep the good stuff. Then I push it out to the team. Sometimes, a pair or triple on the team do this as a group exercise, working history over a few time until it won't break the world.

The parallel to git was eye-opening. In fact, after having noticed this behavior in myself, and seeing the behavior tendency grow over time, I'd say that git encourages multi-pass thinking styles.

P.S. If you care at all about Ruby, listen to Matz's talk. Some of the future stuff he was talking about is already in Ruby 1.9.2. NOTE: I'm on linux, and I had to use the flash player to get the video to show.

Attention to Error vs Attention to Detail

2011-10-18T21:01:00.000-06:00

After having read Talent Code, a friend pointed me to the following article:

Why Do Some People Learn Faster?

Although the author of that article had gotten some lackluster reviews on some of his book-length work on Amazon, this article brought a distinct idea to the forefront for me:

Attention to Error

I've always thought that attention to detail was an important tendency in myself that made me a good learner. But I realized that there is a distinction between paying attention to detail and paying attention to error.

The constant reconciliation between what you believe to be correct and what turns out to be correct is the fuel for my personal learning.

Some people might say this is what the scientific method is all about. I'm less methodical than a scientist would be -- I find it nevertheless useful to constantly put myself in situations where I can learn informally from comparing what I expect to what actually happens.

Link to Paper

2011-10-05T13:56:00.001-06:00

Dear Lazyweb,

I've wanted to link to pages of books, or at least down to the chapter, or subhead.

Take, for example, the following blog post:

http://deliberate-thinking.blogspot.com/2010/04/reality-quotient.html

In that post, I refer to printed, copyrighted content by URL, but with lame google books URLs that have nothing to do with the structure of the book, and that border on the potentially problematic situation traditionally called "deep linking".

Look for the following text in the blog post:

text: Total Useful Mental Discriminations
and link: http://books.google.com/books?id=563gvssRPvkC&lpg=PR1&dq=slack&pg=PA72#v=onepage
text: capable people are credible
and link: http://books.google.com/books?id=31Qe_e61Y10C&lpg=PP1&ots=bBbef5O2a3&dq=speed%20of%20trust&pg=PA92#v=onepage

Do you know of any way that I can manage a list of URLs per book that are just markers for the sections within that book?

Not page linking, but sections as defined by the work itself. No content extraction except perhaps to put the subhead text in the URL itself (either in English, or in the work's native language, or both). Now there would be a global permalink for a given chunk of a work.

So, as an example of what I'm shooting for, the following author has already done this with his book:

http://book.personalmba.com/bootstrapping/ (full of promotional material)

Even though this page is full of promotional material, the link itself has value, because now I can refer to that small section of the book and talk about my own ideas, relative to that section.

And I can do so in a web-friendly way, with a meaningful URL.

The closest think I found was OpenLibrary itself with canonical URLs to Works and Editions. But has anyone done "link to paper" in a general sense?

Sincerely,
John...

Word Mixed With Faith

2011-10-05T13:44:00.002-06:00

The Savior said:

Ye shall know them by their fruits.

Paul wrote to the Hebrews:

For unto us was the gospel preached, as well as unto them: but the word preached did not profit them, not being mixed with faith in them that heard it.

It feels a lot like the recipe for inspiration and blessings from God includes the following ingredients:

Word of God, shared or published
Faith in those who receive it

Mix the word with faith, season well with humility, patience & repentance. Harvest the inspiration and blessings that God wants to give you.

Using dot from graphviz

2011-09-27T14:39:00.000-06:00

The whole graphviz package is an amazingly useful piece of software. Especially the dot program.

I've watched other people hand-craft Visio documents that go out of date really fast.

I've also watched developers try to use design tools for high-level sketch kind of diagrams and get bogged down with superfluous code-sync features.

When I want to illustrate a point, just plain old boxes and arrows work wonders. Especially when I can commit the source and be able to tweak it afterwards.

I've found that dot meets and exceeds the my common use goals. I would guess that 80% of the time, the diagram communicates what I want to say without any tweaking at all. About 15% of the time, it takes some layout/shape/font/color tweaking to get the message across in a clear & direct manner. About 5% of the time, I have to output the graph as SVG and load it into Inkscape for further slight tweaking.

Here are some especially helpful links:

official site
gallery of examples, also
up-to-date language reference, and other documentation
outdated, but very well-organized Users Guide
dot-functions.sh

The last piece of software is intended as a helper for invoking dot quickly from the command line as part of a REPL authoring flow.

To use dot-functions.sh, first download it. The script defines a bash function that can be used from a bash CLI. Source it into the current shell by doing: source dot-functions.sh, followed by dot somefile.dot.

Here is the source of dot-functions.sh:

Another very helpful article was written on this topic by Diomidis Spinellis. Now that I think about it, there is another very helpful article about how to get a hand-written sketch into digital form.

Keeping a Beginner's Mind

2011-09-27T14:09:00.002-06:00

As an experienced software developer, I care deeply about retaining my ability to remain flexible in my habits and learning style. That's the only way I got good, and if I ossify in my learning habits, I'll end up the equivalent of a COBOL programmer. Certainly not the way to live up to the broad possibilities that exist to make the world a better place.

I appreciated the wider perspective that I got from glancing through these slides by Patrick Kua:

The Beginner's Mind

Although I had seen and skimmed Pragmatic Thinking & Learning, this presentation was a gentle and useful introduction to the whole idea of the Dreyfus model of skill aquisition.

Another very useful idea that this presentation expressed was the contrast between "skill-acquiring apprentice" vs. "closed-minded expert". Patrick said that the "skill-acquiring" attribute can also apply to highly-skilled practitioners.

Among the tips Patrick gave, the following were useful to me:

You can't be an expert on everything. [so don't even try]
How can I try this safely?
How does this fit in my world?
Remain curious.
Mix with diverse groups.
Beware of built-in biases.
Avoid judging early.

The reason I decided to compare/contrast some of the ideas in this presentation was actually because of my forays into the Pragmatic Thinking & Learning book, which was one of three "Further Resources" offered at the end.

Patrick recommended the following books for further learning:

Because of the context in which the Apprenticeship Patterns book appears, I want to read that as a next step for learning how to make a real difference at FamilySearch.

Any reason not to post this?

2011-09-07T16:22:00.000-06:00

I remember reading Tim Bray's first post at Google, specifically the part that talked about continuing to post without editorial comments from his employer.

It was then that the whole Cluetrain Manifesto finally clicked for me.

And I realized that the real question wasn't:

Would this topic be something I could post on my blog?

but was really a quick:

Any reason not to post this? (right before hitting the Publish button)

Seems like I've been kind of dense about this sort of thing.

Lazy Developer plus No Slack equals Funding Guilt

2011-08-31T08:00:00.005-06:00

I have enough hubris to consider myself a lazy software developer. I also work in an organization where there is not a lot of slack. Overall, I consider myself very blessed to be a part of the software group in which I work. There are many intangible rewards that I receive personally by working on the projects I'm assigned to work on.

Most of what I wanted to say in this article has already been said, so I'll spare you the effort if you're already well-read in this area.

However, the lazy developer / no slack combination often produces an interesting set of emotions within me. In particular, I repeatedly feel a certain ugly kind of frustration.

Here is my shot at defining this certain kind of frustration:

Funding Guilt: n. The feeling of having a sense that you could solve the problem at hand in a better way and more conveniently by inventing a solution to a more general problem, but being in a position where the investment in that more general solution is not specifically funded by the person paying for the specific assignment and might be more costly in the short term.

A lazy developer's answer to this is often to ignore the context and solve the more general problem anyway, with an eye toward paring the problem down to its core and avoiding gold-plating.

I remember working with a very smart developer who told me he kept an open critical bug as cover for getting real work done. If asked what he was spending his time on, he would point to his efforts to solve the critical bug. He would make enough progress on the bug over a period of time that people would continue to leave him alone, because they really wanted the bug fixed as soon as possible. But he devoted a significant amount of his time each day toward his real work. And when that bug got fixed, he'd pick up another serious bug that looked like it could be of use. Maybe this approach could be called "Bug Cover".

Although that approach to avoiding funding guilt is deceptive at its core, it worked for him. I'd prefer a way to avoid funding guilt that was more above board.

And perhaps funding guilt only appears in hyper-responsible people, of which I am one.

For those of us who feel it, acknowledgment of this emotion sometimes helps create a sense of understanding and perspective in ourselves and others, including possibly sponsors of our work. It is important to be able to forgive oneself for funding guilt if solving the more general problem is really the right thing to do. But this is not a resolution to the core question. How can funding guilt be avoided as a matter of course?

Maybe it's a matter of choosing very carefully which projects you work on, or at least aborting unfruitful projects very quickly.

Maybe the proper response to expressed funding guilt is at the core of the art of great software management. Perhaps great managers are those who can create the sense of slack that is needed to allow developers to get their juices flowing and create great stuff.

Even if it does involve a little cover.

P.S. FWIW, many of the ideas in this post come from having read and digested the following:

Pragmatic Thinking & Learning (personal learning)
Driving Technical Change (organizational rollout affordances)
Mythical Man-month (multi-pass thinking)
using Git on a daily basis (multi-pass thinking)
Pay to Learn when playing the game of software (optimizing for learning)
Sooner Not Faster (optimizing for learning)
Reductionist Agile Manifesto (paring things down to the core)

Heralds of Life

2011-05-01T15:26:00.000-06:00

My sister, Ann Sumsion wrote the following poem on Thursday, and I asked her if I could post it here. She said yes, so here it is:

Heralds of Life

Daffodils, the Trumpets of the Lord,
Speak peace and courage, love and faith,
To souls cold in world's winter.

Their warm and yellow blooms
Are testament of His enduring Grace
And Tender Mercies.

They cry, "The Lord is my Light,
And my Strength, and my Song.
He is my Salvation."

Heads bowed in strong Humility,
They nod in gentle breeze and bend in mighty tempest.
As leaves of grass, they die and fade,
In heat of summer's day.

But the memory of their bright nodding heads
Brought back in dark of night, and chill of frost,
Recalls Life, death overcome.

Their clarion trumpets echo their Master,
And cry, "Spring forth,
And Rise again."

I'm grateful for Ann's friendship and love for me. Her love for and confidence in her Savior are also qualities that I admire in her and want to emulate.

These things transferred to myself

2011-04-23T21:53:00.004-06:00

Paul said (see 1 Cor. 4:2-6, emphasis mine):

Moveover it is required in stewards, that a man be found faithful.

... yea, I judge not mine own self.

For I know nothing by myself; yet am I not hereby justified: but he that judgeth me is the Lord.

... And these things, brethren, I have in a figure transferred to myself and to Apollos for your sakes; that ye might learn in us not to think of men above that which is written, that no one of you be puffed up for one against the other.

Nephi said (see 1 Ne. 19:23, emphasis mine):

but that I might more fully persuade them to believe in the Lord their Redeemer I did read unto them that which was written by the prophet Isaiah; for I did liken all scriptures unto us, that it might be for our profit and learning.

I see the following three ideas present in both statements:

habit of personalizing scriptural teaching
attempt to teach by example
making reference to prior patterns of personalization in a teaching situation

These scriptures are filled with a refreshing spirit of no-nonsense, concrete, step-by-step spiritual teaching. The teachers' attitudes are unassuming and direct.

I've been in teaching/learning situations like this, and it feels really good to have a teacher that both understands the material and is willing to put it on your level when explaining it.

I'm grateful for Paul's and Nephi's willingness to be as frank and humble as they were in these scriptures. It's been a blessing to me to read, compare, and contrast the two scriptures.

Core Goals of Version Control

2011-04-06T22:17:00.003-06:00

After having a couple of years of experience with Git, I was finally able to clearly articulate the core value that version control brings to software development. This article will be written with a bias toward Git, but I've at least tried to express the core value in abstract terms.

The value is expressible in 4 goals.

Core Goals

Capture source artifacts
Isolate stable codelines from WIP
Enable concurrent WIP
Make it easy to leave sensible history behind

WIP = Work In Progress

The continuous delivery crowd says that WIP should be basically zero. I think that there is space for a fairly short development pipeline (3-5d) that can free developers up to capture ideas and then wrangle them into shape in a second or third pass.

Capture Source Artifacts

As a developer, I feel happy when I can push a save button when I've taken a small step -- and then never have think about it again. I also feel happy when I can save, even if I'm based on a slightly out-of-date base. I also feel happy when I don't have to worry about binary vs. text -- as long as its a true source file of a reasonable size.

I feel happiest when I don't have to be distracted by superfluous concerns, and can focus on the task at hand and save the results easily.

Main Point: A good version control system makes it easy to capture source artifacts.

Isolate Stable Codelines From WIP

Software is hard to get right, and once things get stable, the only way to keep them there is to avoid making risky changes. But stability is always balanced against the common desire for enhancement and restructuring.

A typical bug fix is one or two isolated commits that fix a specific problem. Most version control systems more or less support cherry-picking a small change over into another codeline.

I feel happy when I'm able to easily take an isolated series of commits from the development codeline into a stable one, even if the fix turns out to be a little larger than a couple commits.

Main Point: A good version control system makes it easy to cherry-pick changes, and even longer patch sequences, from one codeline to another with easy reconciliation of overlapping edits.

Enable Concurrent WIP

For software developed by a team larger than 2-3 people, it is useful to be able to work in parallel with each other, even on the same feature. Sometimes you can arrange your work so as not to overlap at all, but there are real situations where you want to track someone else's development within the fairly short development pipeline (3-5d) before things have gotten stable.

I feel happy when I don't have to catch people up on what I've been doing, and when they don't have to catch me up on what they've been doing, and we can get to the point easily and quickly. I also feel happy when we can leap-frog each other with ideas and real implementation.

Main Point: A good version control system makes it easy to track other team members' work, and easy to tentatively integrate with that work.

Make It Easy To Leave Sensible History Behind

After stepping away from a piece of software, it is easy to lose context and forget the concerns that shaped the development of that software. It doesn't take long. For me, about 2 weeks is enough for me to start forgetting details and motivations.

Of course, it is important to leave a properly structured artifact behind. Proper naming means a lot; proper factoring is important. Once you comprehend the structure, it is possible to change things without introducing big problems.

But often, full comprehension isn't practical, and a flat 2D view of the artifact is insufficient for reasoning about the thing itself. Often, it is often very useful to be able to get a vector on where the software came from, and interpolate from that vector where it was headed.

The creative process is messy, filled with double steps and backtracking. Don't confuse me with all the noise. Give me a history that, given all the knowledge you had when it got stable, at least looks well-reasoned.

I feel happy when I'm able to take an easy editing pass following capture/review that lets me intentionally craft history as an email to the future about the vector of change that is inherent in a certain patch sequence. I also feel very happy to not have to think about this during the creative, messy, focus-draining capture/review pass.

Main Point: A good version control system includes tools to both: 1) enable the developers to easily leave behind meaningful history, and 2) extract focused history for all or part of a piece of software.