Kevin's Weblog

I was a bit late to the keynotes this morning, but I got there in time for Nat’s talk, which was a bit sad, as he announced this is his last year as the program chair for OSCON, but also a bit inspirational as he gave some advice on family dynamics to all the various open source communities gathered at the conference. After that, James Larsson talked about how to “Pimp Your Garbage”, demonstrating some pretty insane things you can do with your junk (and also demonstrating a slightly disturbing obsession with leather boots).

After the keynotes, I went to back-to-back talks by Robert ‘r0ml’ Lefkowitz. The first was on “Preventing Code”, about how businesses treat code like some sort of dangerous weapon that their employees must be prevented from using at all costs. An example: Windows security settings which prevent unsigned Excel macros from running, and no mechanism for employees to sign macros in spreadsheets they create for work. The second talk was “A Lexicon for Open Source”, in which he observed that people aren’t really sure what a lot of the terms we use in business mean, even though they are formed by combining words we do understand. He suggests that instead of using words which already have common uses, we should dig up archaic words which might or might not have related meaning and just use those, since no one knows what they used to mean and it makes you sound erudite to use them. For example, “reuse” has a common meaning which is really somewhat different from what we mean by “code reuse”. He suggests resurrecting “palimpset” for this use. Maybe we could call open source software “Chrysography”, while the alternative would be decretal software. In closing, he pointed out that contrary to the common claim that there’s no word in English which unambiguously means “free as in speech”, there is and the word is “liberal”. I guess it depends on your point of view whether it’s good or bad that that word already has strong connotations in our society.

The closing keynote was about “Open Source Hardware: A Start”, which might have been interesting if I hadn’t been starving. I’m not sure why they always run the sessions on Friday until 1:30 without any real food.

I didn’t take as many notes today. Really only two talks I went to were worth reporting on.

A talk about DTrace and how they used it to profile the performance of Twitter was quite good. They actually went through a full profiling session to show how you can progressively dig down through the diagnostics to pinpoint issues with a program. It was very inspiring. Some day I hope to be able to use an operating system at work that has DTrace. (I really need to spend some time with oprofile to see how it compares.) I was surprised how few people were at this talk; I wonder if that’s because most people are using Linux and thus it’s somewhat irrelevant to them.

Later in the day, I went to a talk from one of the authors of Jifty about implementing DSLs in Perl. Specifically, he’s talking about ‘internal DSLs’ which are implemented inside the host language. He showed 4 DSLs which they have created: Jifty::DBI::Schema, Template::Declare, Jifty::Dispatcher, and Test::WWW::Declare. These are languages for Rails-like schema migrations, HTML templating, HTTP dispatch rules, and mechanized web page testing, respectively. He talked very rapidly about what was involved to create the DSLs that they wanted and make it valid, working Perl, but honestly I could not absorb it as quickly as it went by. I’m planning to go look at the code more closely at some point to understand how they do it.

At the end of the day, I went to the Perl Lightning Talks, which were a mixed bag and which others took much better notes on. Then there was the Perl Foundation Auction, which took too long, followed by the State of the Onion, which is always hard to summarize, but my take was that Larry talked about all the different choices that go into designing a programming language, then assured us that Perl 6 makes all the right choices (including giving the programmer the ability to override many of the choices if they feel they need to).

On Wednesday, during the conference, someone stole my bike from the rack in front of the convention center. Needless to say, I’m pretty unhappy about this. I don’t have much else to say on the topic.

On Wednesday, the pace picked up a lot. I’m going to have to condense my notes considerably to keep this post to a reasonable length.

I was pretty impressed with the keynotes this morning. Tim O’Reilly had some interesting thoughts to share on the matter of open software vs. open services. We have to think about what openness means when even if you had, for example, Google’s source code, you still couldn’t run the application (since you probably don’t have thousands of CPUs laying around). The Intel guys talked about Threading Building Blocks again. Sort of amusing as they had the “marketing guy in a suit” start the talk, and then get interrupted by the geek in a teeshirt to announce the open-sourcing. Then, keeping with the theme of concurrency, Simon Peyton-Jones talked about software transactional memory, which is basically using a declarative syntax for atomic code sequences.

Andy Lester gave a good talk on “Managing Technical Debt”. First step, you have to identify your debt: ugly code, fragile code, failing tests, TODO and XXX comments, lack of bug tracking or version control, jerks on the team or in management, lack of coding standards, etc. That’s the easy part. Then you have to figure out what the technical debt is costing you (in terms management understands), as well as what it will cost to get rid of the debt. Then start paying down your debt starting with the most profitable. (Not the easiest or most fun.) Make a commitment to not taking on new debt. If you do, you must record it somewhere and track your net “cash flow”. Stay vigilant, watch the corners, automate stuff (testing and standards). Remember: debt management is an investment.

A talk on Seaside and Rail was mostly about Seaside, and was very similar to every other Smalltalk presentation I’ve been to. Basically, it was about how the experience of Smalltalk (and the development environment) is great, and that’s all you need to know. The only real content about Seaside is that it’s continuation-based, but he didn’t address the obvious questions like: what about bookmarking, or sending links to people? If continuations are kept live forever, what about memory leaks? How do you scale horizontally?

Next I want to another talk by Simon Peyton-Jones about “Nested Data Parallelism”. The nested part is having data-parallel algorithms calling other data-parallel algorithms. Trying to do this by hand is almost hopeless. So, instead he says you should let the runtime do it for you. This is in the GHC CVS, although not released. You can write code that’s almost identical to normal array syntax but that gets executed in parallel if you have multiple processors. For example:

vecMul :: [:Float:] -> [:Float:] -> Float
vecMul v1 v2 = sumP [: f1*f2 | f1 <- v1 | f2 <- v2 :]

In this case, sumP also does the sum in parallel, (making it nested). In order to get good performance for this, you need to fuse the two loops to multiple and add in one step. GHC can also do this automatically. The basic summary of this talk is: GHC is nearly magical, and writing data-parallel algorithms is getting much easier

Let’s see... then I went to a talk about the Atom Publishing Protocol, which was a little dull.

Finally, I went to “Myths of Innovation” which was quite good and entertaining. By the author of the book with the same name, this talk was about how most of what people understand about innovation is wrong. For example, we tend to obsess about the moment of breakthrough, ignoring all the context and work leading up to it. We also ignore mistakes and failures. Another big fallacy is that people like new ideas. On the contrary, new ideas that threaten people’s jobs or established habits make them scared. Overall, this was a good talk and I imagine that I’ll pick up the book at some point.

I didn’t go to any of the evening activities. See the next post for why.

Oh, yeah, I should explain the title of this post. I think every talk this year has had at least one lolcatz slide. My feedback to presenters: one lolcatz may already be too many; having every other slide be a lolcatz is not cool.