jessenoller.com

So, sat­ur­day has come and gone — most of it found me heads-down work­ing with Rham­phoryn­cus (Adam) on the python-safethread(freethreading) project try­ing (and suc­ceed­ing) to get the code ported to my OS/X box. Good times.

Yes­ter­day the keynotes were fairly inter­est­ing — Glyph and Dun­can got up and made a great Twisted announce­ment, namely that twisted is now a rec­og­nized non profit soft­ware foun­da­tion (Twisted Foun­da­tion). That’s great news — and they also announced their first spon­sors as well. Con­grat­u­la­tions to the twisted guys.

After that, there was an amus­ing, and very good talk by Brian Fitz­patrick called “You *can* fool all of your users all of the time”. In it, he out­lined a lot of great points about lis­ten­ing to your users, cus­tomer ser­vice, and putting the users first.

I think he had a lot of good points that get for­got­ten by a lot of peo­ple in soft­ware — he also out­lined the ten­ants which have helped make google suc­cess­ful (Putting your users first, speed mat­ters, etc.). He really is a fan­tas­tic speaker, and I hope peo­ple keep his points in mind.

One of the best points he had was that all abstrac­tions leak — and many peo­ple spend their time try­ing to close off those leaks. He coun­tered with “keep it leaky” — the rea­son being, is that you make an abstrac­tion to keep it sim­ple for some users, but keep­ing it leaky means that users with more tech­ni­cal apti­tude can then use it in m ore advanced ways. The exam­ple he gave was the google search page — most users type a string in, advanced users use state­ments, for­mu­las, etc.

The sec­ond (3rd?) Keynote was done by Van Lind­berg, a lawyer pri­mar­ily focused on IP. In it, he out­lined some less than pop­u­lar views on Intel­lec­tual Prop­erty. I really appre­ci­ated his out­line of how it came into being, the eco­nom­ics of knowl­edge out­line, etc.

I can say that a lot of peo­ple were grum­bling to many of his points — a good chunk of the peo­ple in the room are IP abso­lutists, lean­ing towards the more RMS view of IP in total­ity. I really did enjoy it, and I thought he raised some inter­est­ing food for thought for many people.

Admit­tedly, the patent sys­tem in the us is bro­ken — no one dis­putes that, but knowl­edge does in fact, have a cost to cre­ate, and like any cre­ation, peo­ple will want to be able to use that knowl­edge to gain wealth. This con­cept is not exclu­sive to the con­cept of open source/etc.

But that’s all I’ll say about that. I think Van was a decent speaker, he stum­bled at times, but his pre­sen­ta­tion was filled with good information.

I ended up hav­ing to leave early to run to an open space talk on Mul­ti­core pro­gram­ming with Bruce Eckel/Ted Leung and oth­ers. Catch­ing the tail end of the dis­cus­sion, they were pri­mar­ily focused on the Actor Model and how to use it within Python/how it’s imple­mented in other lan­guages. A lot of the con­cur­rency dis­cus­sion at the con­fer­ence has been pri­mar­ily focused on alter­na­tive inter­preters — namely Jython, PyPy and IronPython.

Given I only caught the tail end, I sug­gested we have another dis­cus­sion on con­cur­rency later in the day (more on that later).

After that, I slipped in to catch the middle/end of the “Dec­o­rated State Machines” talk — I missed the intro, so com­ing into it late, given the den­sity of the infor­ma­tion, made it incred­i­bly dif­fi­cult to grok what was going on.

So, I skipped over to “Man­ag­ing Com­plex­ity (and test­ing)” which was Fan­tas­tic — Matt Har­ri­son did an excel­lent job out­lin­ing key con­cepts for code cov­er­age, code com­plex­ity and designing/testing prop­erly. He also out­lined the key mea­sure­ments used in code cov­er­age and how best to apply them — I really learned a lot from his pre­sen­ta­tion. He’s uploaded his slides here.

Next up, the ever effer­ves­cent Alex Martelli’s talk on “Call­back Pat­terns and Idioms in Python” — again, another fan­tas­tic, infor­ma­tion rich talk. I can’t say enough about this talk too. From a tech­ni­cal bent it was spot on and didn’t bog down at all. You can get his slides from here.

The next hour or so was a blur — why? I was heads-down work­ing on the free thread­ing stuff.

So, the next time I came up for air was for the py.test talk, which was quite inter­est­ing, and I’m going to fol­lowup on using it + nose for some inter­nal work. A lot of great infor­ma­tion, if not a rough presentation.

I dropped out of the light­ning talks to attend the open space dis­cus­sion on con­cur­rency — a lot of peo­ple showed up, and a lot of good ideas were talked about. I took some time to pimp processing.py and the free thread­ing work. It def­i­nitely does seem like there is an itch in the com­mu­nity to scratch.

The biggest thing I can say to that though, is that peo­ple need to real­ize that sim­ply dis­miss­ing thread­ing, shared mem­ory and exist­ing method­olo­gies to build­ing parallel/concurrent appli­ca­tions as “wrong headed” is a bad idea.

The last thing we want as a com­mu­nity to sim­ply dis­miss these — instead we should approach the prob­lem with a multi-homes approach. Work on fix­ing thread­ing, sup­port the Actor model and look into a func­tional and OO method of con­cur­rent pro­gram­ming. (More on this later).

Lots of thoughts about this really, and I, as well as oth­ers need to real­ize there are many, many prob­lems in this space look­ing for solu­tions, and no one solution/tool will address all of them.

And, I got the free thread­ing stuff com­piled on OS/X. Woop.

So, saturday has come and gone - most of it found me heads-down working with Rhamphoryncus (Adam) on the python-safethread(freethreading) project trying (and succeeding) to get the code ported to my OS/X box. Good times. Yesterday the keynotes were fairly interesting - Glyph and Duncan got up and made a great Twisted announcement, namely that ...