RubyConf Video is Posted

Looks my the video for my RubyConf presentation, Essential Incompleteness in Program Modeling (which I subtitled How to apply hand-wavy math to software design), has finally been posted. The slides are also available in PDF.

It's a strange talk, that's for sure. For one, it doesn't really have any code in it. And when I say "not really", I mean "none". I only even mention Ruby when talking about Puppet. For two, I kinda submitted the talk on a lark -- my Ruby submissions seem to be largely uninteresting to the Ruby community, so I figured I'd submit this as practice but that it would be denied. When it was actually accepted, I had to go write the darn thing. Third, I did relatively poorly in the presentation. I think the content was actually pretty good, but I did a poor job of organizing the slides and of presenting it. That isn't to say I think it's a bad presentation, just that it could have been much better.

It'd be interesting to be given the opportunity to give the talk in a different environment, somewhere I was just thinking about the talk and not worrying about its appropriateness.

Either way, the talk was an earnest attempt at providing what I think is a cool and useful way at looking at software design, and it's worth a look.

Sat, 29 Dec 2007 | Tags: conference, ruby, rubyconf, rubyconf2007, presentation

RubyConf Slides

Jim Meyer is collecting slides from RubyConf, so I've posted my slides for the Essential Incompleteness in Program Modeling talk I gave there.

It's a pretty hand-wavy talk, and has no code whatsoever, but I'm relatively happy with the content if not the specific flow of the talk. I generally don't make very useful slides, since it's much more about my talking than my showing you stuff on the screen, but hopefully the slides will be useful to someone.

Mon, 19 Nov 2007 | Tags: conference, rubyconf, rubyconf07, rubyconf2007, slides, godel, incompleteness, ruby

My Submission to RubyConf

I've once again submitted to RubyConf, but I've decided to skip much mention of Ruby, since I was getting no traction there. Instead, I've decided to try to get a talk accepted on how I manage Puppet's model. Here's the short abstract:

Model-based programming is based on constructing a model that matches reality, but Godel has shown that for sufficiently complex systems the model can never quite match reality. Viewing model-matching as a constant, fractal process rather than a static fit provides more flexibility in modeling and thus informs both design and ongoing maintenance of the model. This talk uses the model of Puppet, a server automation tool, to demonstrate how model refinements are always fractal and even at best cannot completely model reality.

And the long abstract:

One of the most important mathematical theorems of the 20th century is Kurt Godel's Theorem of Essential Incompleteness, which proved that the real numbers are incomplete, meaning that there are true but unprovable statements in them. This proof immediately and drastically changed mathematics, because mathematicians had to come to terms with the fact that the real numbers did not perfectly model reality -- if they did, then you could use them to arrive at any valid statement in reality. Where mathematicians were previously treating the real numbers as a perfect model, their theorems now had to take the imperfection of the model used to create those same theorems.

A more general form of Godel's theorem, rephrased to better suit programming, is that any model of a sufficiently complex system contains valid but unreachable states. You cannot hope for a perfect model, and assuming that you can will only result in missed deadlines and plenty of pain. While Godel in some ways presents a limitation, seeing the limitation can itself be powerful as long as we treat it appropriately.

Thankfully, most programming models are not sufficiently complex to be subject to Godel -- in particular, Godel's proof requires some support for self-reference. Unfortunately for me, the system that Puppet is meant to model is sufficiently complex, because it is meant to model and manage the full range of configuration possibilities on a network of arbitrary numbers of operating systems, services, and any other aspects.

It's immediately clear that this model is complex, but understanding that this model is actually impossible to entirely model -- according to Godel -- gives us the power to understand that our real problem is not modeling the system but building a process for managing our model so that it can always be refined as we get more data. Knowing that we will never perfectly succeed frees us from seeking perfection in the first place.

This model-finding process, enabled by the impossibility of success, becomes fractal and asymptotic. We can continually refine pieces of it, and with each refinement the model becomes higher-resolution and better approaches reality. Because I have retained flexibility in how I define Puppet's model, it has been able to change to reflect our better understanding of the system it is meant to model, and it can even respond to changes in that system. If I had somehow convinced myself that it was possible to achieve completeness in my model, then I would either be stuck seeking perfection yet accomplishing nothing or being convinced that the current solution is already complete, either of which would quickly leave me behind.

This talk will provide a high-level view of how Godel has enabled refinements of Puppet's model over the years, with some pointers for how your own modeling can be made both more flexible and more powerful by acknowledging its essential incompleteness.

I expect I'll get the same response as before, since the Ruby world doesn't know me from Adam and doesn't seem to care one way or another that I've got a large, interesting project written in Ruby, but I figure taking a different tack can't hurt.

Mon, 20 Aug 2007 | Tags: ruby, rubyconf, rubyconf07, travel, conference