canspice.org

Wednesday morning sees three keynotes and one interview session. Tim O’Reilly will be talking about Open Source on the O’Reilly Radar, James Reinders and Dirk Hohndel will be present the Threading Building Blocks again, and Simon Peyton-Jones will talk about Transactional Memory for Concurrent Programming. The interview sees Tim O’Reilly sitting down with Mark Shuttleworth.

Nat Torkington welcomed everybody to the conference, talking about the opening-up of society. The principles of Open Source software are creeping into other facets of life: computer hardware, body hacking, open democracy.

The O’Reilly Radar is essentially a brain-dump of what Tim O’Reilly’s thinking about. One of his fundamental beliefs is that the future is all around us, and we just have to see the patterns to determine what’s going to be big. He sees an issue in the ties between hardware and software, using Google as an example. Google’s software could be open and available, but it probably wouldn’t do anybody any good without the hardware to run it on. Open Source did not spring just from a set of licenses, but from a set of practices. We should be paying attention to projects like Wikipedia and OpenID. OpenID is racing to keep identity on the web open. Factors that have helped Open Source succeed are frictionless distribution, collaborative development, freedom to build on, adapt, or extend, and the freedom to fork. There are a number of projects that look interesting, including Hadoop, Foxmarks, StumbleUpon, and Intel’s Threading Building Blocks.

Which leads into James Reinders and Dirk Hohndel talking about TBB and multi-core parallelism. It was well done, with Reinders in a suit giving a presentation on how you can buy TBB, only to be interrupted by Hohndel, who then talked about Intel’s work with open source. It’s got graphics drivers, wireless drivers, power, and kernel, and is moving into mobile and internet linux devices. TBB needs to be open everywhere, across compilers, processors, and operating systems. It provides algorithm templates, a new memory allocator, and other things that I didn’t write down. It can be used with C code, so long as you compile it with a C++ compiler.

Simon Peyton-Jones says that there are two ways to do parallel programming: task parallelism and data parallelism. This keynote’s focus is task parallelism, where the state of the art is 30 years old: locks and condition variables. They’re fundamentally flawed: “it’s like building a skyscraper out of bananas.” So what’s wrong with locks? You can get race conditions, deadlocks, lost wakeups, and diabolical error recovery. And they’re absurdly hard to get right. Atomic blocks, the solution to all this, makes it easy again. How do you do this? Take your code, wrap atomic{ } around it, and then the code inside runs as “all or nothing” in a manner very similar to transactions in database land. So how do you actually make this work? One way could be to execute the code without taking any locks, and as you run through it you write only to a thread-local transaction log, not to memory. When you’re done, the transaction tries to commit to memory. Transactional memory looks incredibly cool, and it’s available in STM Haskell now.

And then I zoned out, so that’s the end of this post.