Kevin's Weblog

With one child in college and three to go, the Kent started thinking about the economics of software. Concluded that open source is nonsense. Not saying he won’t do it, or that you shouldn’t, but just that you should be aware that it’s nonsense when you do it.

A goal of society is to apply scarce resources where they do the most good. Money is a tool to do this. Money is information about what is valuable in society (mostly, not perfect). How does the OS movement figure out what is important to do if not with money? Prediction: open source will result is really good software with minimal impact.

Ex., rough estimate of value created by JUnit is $1 billion / year. Kent Beck’s profit: $0. Geek cred is nice, but doesn’t pay for college (or food, or rent, ...).

Maslow’s hierarchy of needs: survival, love, esteem, self-actualization. Must fulfill lower levels before you can proceed to higher levels. But, open source turns this completely on its head. Do what you want, maybe then get recognition in community, maybe then form close relationships, only very few manage to fulfill survival needs through OSS.

Pricing in traditional economic: price set by a seller is a statement of worth. Price paid by a buyer is a statement of perceived value. We (OS developers) think we are making items of value, but to most of the world a price of $0 signals otherwise.

Situations that don’t make sense are warnings of impending change. In what direction will change happen? Hard to say, but if we are aware that change is coming, maybe we can steer it in a direction that is good for the creators of value. But, if you don’t pay attention, MS will capture all the value instead.

Accountability: software development doesn’t have a good history of accountability. Increase in test-driven development is a step towards accountability. OSS tends only to have peer accountability. The problem with your peers is that they tend to let you off the hook. “Oops... it was 3AM and I made a mistake”.

Why does OS seem to work? The first world is a land of plenty. If you have a technical background, you can’t fall that far. At least in the short term, people are willing to sacrifice basic needs for higher needs (doesn’t work so well in the long term, though. Do need sleep, housing, food). Programmers are willing to write software instead of being involved in other hobbies or local community.

How could it work in the future? “Whole people working whole jobs”. Sponsorship (why not USPS JUnit instead of cycling). Patronage (shortage of interested wealthy people, audience member recommends Public Software Fund). Pay-per-use (direct feedback for developers). Licensing. Complementary products.

Preable: big “thank you” to Larry Wall for making this all possible. If everyone in this room got their company to donate $500 to The Perl Foundation, it would be more than enough to keep Larry working on Perl for the whole year.

Desire from someone: implicit $self-> for method calls inside a class module. Sub::CallAsMethod does this. Very simple. Very magical. Probably evil.

This talk is about modules that are indistiguishable from magic.

hmm... blah blah blah... Harry Potter jokes without end...

Modules which do magic without any user interaction aren’t new. Most famously, use strict. More recently, IO::All. But, maybe not magical enough...

use IO::All:Pulp::Fiction
my @horrors = <~/foo.txt>

Lots of stuff in the Perl6:: namespace.

How can mere mortals write S.A.T.? Find the clunky bits of your code and do something about it! IO::Prompt was pretty cool, but originally needed too many flags. Changed to autochomp by default and autodetect boolean context.

Why can’t comments be more useful and interactive? Progress module presented last year weren’t simple enough to use. Solution, smart comments:

use Smart::Comments
while ( ... ) {     ### Preparing--->done
  do_work
}

also provides checks and assertions.

Wrapped up with Lingua::EN::Autoinflect, which is like Lingua::EN::Inflect, but with no interface, just works.

Takeaway: look at the interface of your modules. What could you remove? What could you just infer? Could you have better defaults? Could you use objects with overloaded operators to acheive things with more natural usage?

It’s pretty hard to do this justice, but check out the David Rumsey Map Collection. Amazing historical maps with the ability to compare, overlap, evolve, and knit maps.