Kevin's Weblog

I took the shotgun approach to this year’s OSCON call-for-proposals and submitted 3 talks. My biggest fear was actually that all three might get accepted. But, it worked out as I hoped and they picked just one. I’ll be talking about “Beautiful Concurrency with Erlang”. The talk will be an improved and expanded version of my presentation to PDXfunc last month, demonstrating how easy it is to convert sequential programs in Erlang into concurrent / distributed programs taking advantage of your multi-core machine, or a cluster of machine.

I’m slightly nervous, because I’ll freely admit that I was likely selected to give this talk more because I’m good at writing proposals, than because I’m the most qualified person out there to discuss Erlang. That said, I’ll make an effort to draw on the expertise of others to help make the talk as good as possible and as effective as possible at drawing new people into the community.

As a minor aside, I’m currently scheduled for Wednesday morning, which is ideal as far as I’m concerned. I get to give my talk, then relax and enjoy the remaining 2 days of the conference.

I figured I should write a few words on my overall thoughts about this year’s OSCON. Although it’s a bit hard to remember precisely, I felt like it was a better conference than 2005, despite the absence of Damian Conway and a couple other luminaries. Certainly the keynotes were a vast improvement. I do hope that next year sees the return of the Tuesday Evening Extravaganza, though.

It seems like there was a lot less blogging at the conference. Or, perhaps it’s that there was less use of the wiki, and so I just didn’t know about much of the blogging. I did make much greater use of IRC this year, though, and it paid off in a few new friends: Chris, Brad, Alasdair, and others without blogs.

Somewhat unexpectedly, living in the same place as the conference actually made things somewhat tougher. I had to wake up 30-45 minutes earier than I would have if I’d been staying at the hotel. Partly that’s my own choice though, for being too stubborn to drive to the convention center, even after my bike got nicked. Of course, it’s also hard to balance family demands with the crazy schedule of the conference. I’m thinking next year I’ll send them off on vacation for the week or something.

I didn’t get much of anything out of the tutorials this year. Unless there’s something that really looks like it’ll be exceptional, I imagine that I’ll skip them entirely next year.

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, 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.

On Tuesday morning, I went to the “OpenID Bootcamp”. A lot of the material was stuff I already knew about the protocol, but there were some interesting points they made that I hadn’t thought about before. For example, they pointed out that most security concerns that people have about OpenID also apply to email. For example, while OpenID being a relying party means that you are “outsourcing security” to the OpenID provider, if you send out forgotten password emails to users, you are also relying on the security of a third party (the user’s email provider).

In the latter part of the presentation, they talked about some interesting new stuff on the OpenID horizon. Some relying parties may want to whitelist providers to those they trust or those who provide a sufficiently strong level of authentication. Both Microsoft and Verisign have schemes for bringing the authentication process closer to the user and the user’s local machine to remove the potential for phishing. Verisign has made a Firefox plugin that manages your OpenID identities. Microsoft runs a local application to manage interactions with providers and relying parties.

In the afternoon I went to Schwern’s talk about “How To Be A Better Programmer”. He started with the claim that Computer Science + People = Software Development, and that while we’re pretty good at the CS part, dealing with people is a lot harder. He spent a fair bit of time stressing the importance of continuous learning. Learning is hard, particularly when you already know one way of doing a task (like learning Dvorak when you already can type QWERTY). But, expanding the ways you think about things pays big dividends in the end. Learning new programming paradigms can help you recognize a substantially simpler way of solving certain problems. And, talking with people outside the technology team and learning how they think about the business problems makes you much more valuable to the company. Two phrases to practice: “Tell me about it” and “Why?”. He also stressed that email is one of the most difficult and problematic modes of communication. People get angry really easily in email and stop talking productively.

The second half of the talk dealt more with the actual practice of programming with some fairly familiar suggestions like: document as you code, test copiously and automatically, and use version control obsessively. In particular, he stressed keeping each commit limited to a single change. Doing this probably means you want to branch freely, and maybe use a distributed version control system. Another interesting phrase he brought up was “Fear-based Programming”, which is where you get into a mode where fear keeps you from actually doing anything. I think that’s probably a concept that most people working on large systems can relate to.

I skipped the monday morning tutorials. There was nothing that looked really interesting, and I know from experience to pace myself. In the afternoon, I went to “Linux Performance Monitoring”. The talk was decent, but unfortunately it was considerably more basic than I had hoped, covering the basic tools that ship with the distros: vmstat, iostat, sar, and friends. I learned a couple little things, like using dstat to match interrupt counts to devices, but for the most part this is stuff I’ve already been using for years. I was hoping there was going to be some more advanced or newer stuff, like oprofile or systemtap, but there was nothing like that.

In the evening, I sort of crashed this Intel “press event”. It was supposed to be for bloggers (hey, look, I guess I’m one of those) and semi-invitation-only, but the invite URL was getting passed around. At any rate, they didn’t seem to upset about a few people who weren’t on the list. They fed us and gave us drinks, then had a presentation about processors and multi-cores and how thread programming sucks, as a lead-up to “The Big Announcement”, which is that they are open-sourcing Threading Building Blocks (and porting it to a number of OSes and architectures). I haven’t had time to look at it closely, but it seems like a pretty cool library for doing concurrent programming in C++. Sort of like an STL for concurrency. They gave everyone a copy of the book, so I guess I’ll learn a little more about how it works sometime soonish.

It hasn’t quite sunk in that OSCON is starting tomorrow. I guess that’s because I don’t have to travel this year. I’m just going to wake up in my bed, and instead of heading into my home office, I’ll drive/bike/bus to the Convention Center. Definitely a strange change.

(I think I’m going to bike to and from the conference, but I haven’t decided completely. Usually OSCON happens during the most brutally hot week of the summer in Portland, but the forecast for next week isn’t too bad — mid 80s and partly cloudy. I’ll probably bike in tonight to get my badge and see how it goes. Of course, I really should get in some training if I’m going to ride in the BridgePedal in a couple weeks.)

This difficulty in internalizing that the conference is starting really soon means I still haven’t really looked at the schedule too closely. I picked out tutorials a couple months ago, although I need to review my selections and make sure I don’t want to make any last minute changes. Beyond that, it’s pretty wide open. The Perl track is really light this year; once you remove the talks that are repeated every year, there’s less than 10 sessions. But, this is just a good excuse to get exposed to something new. I’m just not sure what that’ll be yet.

Unsurprisingly, I got up a bit late and missed all the keynotes, and half of the first session, which didn’t really have anything that was tempting me strongly anyway. Chatting with people in the hallway did yield the quote of the day. Overhearing us griping about the prices of some technical books, Nat Torkington piped up with: “It’s very rare that [O’Reilly] would make a book that fails so miserably that we have to charge $80 for it”. (Most technical books are expensive because no one buys them. Take that, Econ 101!)

For the last non-keynote session of the conference, I went to MJD’s talk You Can't Get There From Here. It was a little disorganized. He said that his daughter was sick and up most of the night, which I can definitely sympathize with. By popular demand, he jumped to the end of the talk first to explain how you flip a coin over the phone, and how you can use NP-complete problems as a method of proving your identity. An interesting point here is that we actually understand a lot about how hard problems like the traveling salesman are. However, we don’t really know how hard prime factorization is. After that digression, which actually took most of the scheduled time, he jumped back to the start to explain just what NP-complete means, and started to discuss the halting problem and why it isn’t NP-complete, but something completely different. At this point, we were way over time and the closing keynote was starting. Some people stuck around for more of the talk, but I switched rooms.

I’m not really sure why I did. The closing keynote didn’t actually catch my interest and I ended up spending most of the time catching up on websites and blogging about Thursday. The main thrust of the talk seemed to be that open source can produce all the eye candy that the Mac has, which is nice and all, but I really don’t need the jabs about people using Macs not believing in open source. Until Novell open sources all their products, that’s just hypocrisy.

There’s always a ton of people I want to say good-bye to at these conferences, and I almost always end up disappointed. In this case, I needed to hurry to get on the road to Ashland in time to catch a play, so I had to cut things particularly short. It was a little disappointing, but to compensate, the Shakespeare was outstanding.

Wednesday night we crossed the river for a splurge at the Portland City Grill, which was very nice, but took a long time and it was midnight by the time I got back. So, once again I missed the Stonehenge party. Honestly, I’m not that disappointed; from what I’ve heard, I don’t think it would really be my thing.

I started Thursday at Ask’s talk on Real World Scalability. I was interested to contrast what he had to say with what I talked about. While we differ in a couple implementation choices, overall the ideas are similar. He spent a lot more time in his talk hammering on the idea of thinking horizontally for effective scaling. One thing I did get out of the talk was a reminder about perlbal, which I think I knew about at one time, but it had passed off my radar.

At the lightning talks, the one that caught my interest was kinosearch, which I might check out with the intent of writing a Blosxom search plugin using it. I need to find out more about how it tokenizes and normalizes terms, though. I started down this road myself last year at OSCON because I wanted to get reasonable indexing of Perl code, but I ran out of steam to complete it.

The big event of the afternoon was why the lucky stiff, doing something I can only describe as avant garde / absurdist performance art about Ruby.

Later on, I went to Project Estimation and Tracking that Works, which was basically an extended example of how to track project velocity and burn-down rate. Since we’re doing some Scrum development at work, this was nothing particularly new for me.

After the sessions, I spun by the ADC event for appetizer bits, then headed back to the hotel to get most of my packing done, then went to dinner with a few of the other Yahoos: Michael and his wife, Ryan, and Eleanor. Post-dinner we returned to the hotel too late for the MySQL party but found a few lingerers in the bar. Eleanor and I sat down for a round and blue-haired Chris appeared, and the three of us hatched a plan to go seek out entertainment of some variety. A couple phone calls established that a few people were hanging out at Aura. Did I say a few? I mean, about half the conference, or so it seemed. It was quite a crowd when we got there and found Andrei, Marcus, Laura, and about a dozen others whose names I’m forgetting or didn’t know. Geoff Young, Greg Stein, and a couple others rolled in shortly after, just in time for us to get kicked out by the midnight last call. We headed around the corner, where we crammed into Cassidy’s. More drinks were procured, more people appeared, and we learned that New Zealanders call a Buttery Nipple something much more obscene. Once again, we were kicked out by last call, this time at 2:30. Since the Max stops running at 12-ish, we piled into cabs and our group ended up at the Marriott, where we sweet-talked the night staff into letting us into the hot tub. Sometime around 5, we finally called it a night (some more reluctantly than others) and stumbled to our respective beds to get to sleep before the sun was entirely up.