ACCU Friday

Well we made it back to Indiana last night after about 12 hours of blissfully uneventful travel. Friday at ACCU/PyUK was fairly interesting, although not as “darn cool” as the Nokia presentation Thursday. After the previously covered keynote, the morning session on the Python track was John Pinner’s presentation on PayThyme, an open source, Python based payroll system. Even though John chose my presentation on Thursday as his nap time (from the front row, I might add), his presentation was one I had missed at PyCon, and which Vern had indicated was slightly interesting.

The most interesting thing about the talk was the brief discussion of business model. Clocksoft, John’s company, licenses their software under the GPL. While there may be valid skepticism about making money from support for commodity applications such as word processors and spreadsheets, John made an interesting point: everyone has to do payroll, no one wants to figure out the changes to the law every year. And since it is so integral to businesses across the board, everyone is willing to pay for a reasonable support contract. I think that if someone is looking to make money off of open source software, this is an important point: look deeper than the apps on “everyone’s” desk for the app that only a handful of people in the company use, but which is vital to operation: payroll, accounting, etc. These aren’t the sexiest apps to write, but people are willing to pay if they work right (and often, from my observation, even when they don’t).

The first block of the afternoon’s Python track was devoted to two XP related talks. First, about sprint driven development, and second regarding doctest. Both were interesting in passing, although I didn’t really learn anything new and spent most of the time playing with the Nokia Series 60 Emulator.

The final block of the day consisted of two talks I was looking forward to: Aspects in Python and Network Protocol Development with Generators. One talk met expectations, the other did not. First, I had hoped Aspects in Python would provide me with a greater understanding of what AOP is, and how it can be useful. Before the talk all I knew was that AOP consisted of marking areas of your code as able to be overriden or supplemented by other code. I’m not sure I really can answer the questions any better after the talk.

The real problem, I think, is that the presenter attempted to demonstrate how to implement a small-scale aspect system in Python, coming from a Java background. We have no lack of examples of people porting Java code to Python only to end up with Python code that doesn’t pass the “smell” test; that is, it’s right, it works (often well), but just doesn’t “smell” like Python, so there’s some aversion to continuing to use it. This aspect system was just like that. The biggest problem is that the presenter’s system went to great lengths to provide methods for wrapping code with common idioms, such as transaction handling. This in and of itself makes a great deal of sense, and is a great place to use decorators. But the presenter was resistant to decorators, calling them “Java annotations light”, and stating they “clutter” the code. Instead he advocated placing the wrapping (“weaving” in AOP terminology, apparently) after the code declaration, at the end of the module in his example.

Of course, when asked by a C++-track visitor how novice programmers could be made aware that the code they were editting was wrapped, he lamented the fact that there was no IDE support for AOP-in-Python today, and how that was often how Java programmers dealt with it. Instead, he recommended explicit commenting. I then commented that it seemed like he just made a case for using decorators instead of his approach, since it keeps the “weaving” and code close together and is often quite descriptive and explicit. He wasn’t convinced, and I wasn’t impressed.

The second talk was presented by Michael Sparks of BBC R&D on Kamaelia and Axon, their Python toolkits for creating single-threaded, psuedo-state machine network protocol implementations which they can use to test and development protocols for delivering multimedia to thousands of users simultaneously. The most interesting thing about their toolkit is the use of “inboxes” for communication between layers. That is, they have the idea of “inboxes” and “outboxes” in an object, which can be chained together to pass along responsibility for processing and handling.

For example, a LiveAudio object might have an outbox which consists of a raw PCM feed. An Encoder object’s inbox could be connected to that outbox to receive the raw feed, encode it in Ogg, and then pass it out to the inbox of a multicast server. Using Python generators, Axon and Kamaelia make this passing trivial, and the scheduler (which is currently a brain dead, straight forward approach, but could be replaced independently for better performance) activates the correct code object as necessary. Very cool.

Overall I’d say PyUK was a success. I came away with several ideas I want to explore, and saw some new things I hadn’t run into before. It’s hard to make a direct comparison to PyCon, however. Due to its ascociation with the ACCU, PyUK definitely has a more of a computer science focus. PyCon, on the otherhand, embraces non-CS applications along side really geeky discussions of optimizing memory management which is rather refreshing. Both are interesting in their own right, and I hope that the organizers of PyUK (er, Andy) continue to increase the offerings of talks next year, both in terms of quantity and overall quality. Good job guys, maybe I’ll cross the pond again next year for another go round.

date:2005-04-24 11:37:10

ACCU Keynote, Day 2

This morning’s keynote wasn’t nearly as interesting as Bjarne’s yesterday. I say this even though I have little desire to code in C++; I still enjoyed Bjarne’s keynote from a purly theortical perspective.

Jim Coplien gave a talk entitled “The Curse of Symmetry”, but I’ll be damned if I could figure out exactly what that curse was by the end of the hour. All I could figure out was, he thought it was bad, even though starfish and milk drops have some symmetrical properties. Oh, and Bjarne isn’t symmetrical. I was actually sitting directly behind Bjarne, and it was more interesting to watch him shake his head in what appeared to be anguish as Jim spoke. So at least I wasn’t alone. Who knows, maybe I was just part of the 50% that didn’t get it, but the other 50% loved it. I guess by my own definition, that’d make the keynote a success.

UPDATE: I forgot to mention the highlight of the keynote, which was a joke told by an audience member. I have no idea what the context was, but the joke was rather amusing:

So America was helping Iraq write their new constitution. But then they realized they weren’t using their own, so they could just give it to Iraq.
date:2005-04-22 04:51:02

London Calling

So today was my first day at PyUK, which is being presented as part of the ACCU Conference. The day opened with a keynote on improving generic programming from Bjarne Stroustrup (of C++ fame). Bjarne’s presentation centered around the development of a concept he referred to as “Concepts”. Concepts attempt to completely and perfectly separate the declaration and implementation of templated code. If effectively implemented, they allow programmers to make predicate declarations about the signatures of templated code as well as the parameters. For example, without knowing type you could make the assertion that a templated function requires an iterable paramter. A crappy example, but the jet lag is still killing me.

After the keynote the Python track proper started. The remainder of the morning was consumed by Andy Robinson’s brief presentation on PyUK and the ACCU, a repeat of Greg Stein’s PyCon Google keynote, and an unscheduled appearance by a developer evangelist from Microsoft on IronPython. While the IronPython presentation was mostly a rehashing of Jim’s PyCon keynote, it was interesting for a couple of reasons.

First, the presenter (I really wish I could remember his name) went from zero to implementing a C# delegate in Python and calling it from Python in under 24 hours. Admittedly this was with the help of Jim’s slides, but it’s impressive none the less. It lends credence to Greg Stein’s 2-2-2 rule: You can understand Python in 2 hours, write Python in 2 days, and be proficient in 2 months. Second, it helps to allay my fears (somewhat) that IronPython is going to be given the short end of the stick by Microsoft. I can’t give any justification for my fears, it’s just a feeling. Hopefully I’ll be proven wrong.

After lunch, I presented a longer reprise of my PyCon talk on Desktop Applications. With a 90 minute time slot, I was able to go into some more detail on specific cross-platform issues, as well as talk about i18n for wxPython and the beginning of my testing framework implementation. Updated slides and the sample code are available. Despite the gentleman in the front row falling asleep (thanks, buddy), I think the talk was a success. If I had to guess, I’d say it was either too linear or too in depth for about half the audience, but the other half really got it and seemed to appreciate it based on the feedback afterwards. I call that a success. If I were to submit the talk again, I’d probably want to use the 90 minute material in a 45 or 50 minute slot, just so the pacing would be a bit quicker.

After my talk there were two more excellent talks. First was a presentation from Tallgren of Nokia’s R&D group. He presented historical and developmental background regarding Python on the Nokia Series 60. While it sounds like there are still issues to be worked out regarding distributing applications (i.e., how to distribute your Python app and the runtime in a single bundle), it’s definitly exciting to think about how it will lower the bar for development.

The final talk of the day was originally to be presented by Kevin Altis. Alex Tweedly, however, did an excellent job of discussing PythonCard. PythonCard is a simplified wrapper around wxPython. Altis’s development philosophy has been to focus on the simple tasks for which wxPython is too heavy, and that not all the wxPython functionality should be exposed to users. When I last looked at PythonCard, it was an interesting toy, but not something I felt would work for “real” development. I think I’ll need to look at it again to reevaluate that conclusion.

Tomorrow’s talks look excellent as well, and I’m looking forward to reading the new Knuth fascicles I picked up at the Blackwell’s display today.

PS: Apologies for the cheesy title… I couldn’t resist.

date:2005-04-21 15:24:46

Mr. CC Goes to Washington… and Oxford

It’s time for that annual rite of Python: PyCon. Once again scheduled for late March in Washington, DC, this year I’ll be pulling out two dogs and ponies (or is it one of each?). First, and most importantly in my mind, I’ll be presenting on our experiences developing ccPublisher and ccLookup. More to the point, I’ll be taking a pragmatic look at cross-platform development and deployment with Python and wxPython. Should be a good time.

My second presentation is going to be on using RDF with Python. It’s considerably less fleshed out than the former, but I hope to communicate what I’ve learned about RDF in Python. Things which would have been useful to have laid out in a straightforward, pragmatic manner when I started working on Creative Commons projects.

In other, slightly more exciting news, my Desktop Applications talk has also been picked up for the PyUK conference, otherwise known as the Python track of the ACCU 2005 Conference, taking place in April in Oxford, UK. If you’re located near Oxford and want to meet up to chat about CC, Python or both, drop me a line.

date:2005-01-18 15:35:40
category:geek, pycon2005, pyuk2005