Monthly Archives: August 2007

Python 3.0 alpha 1 now out

After last week’s sprint at Google, the first alpha of Python 3.0 is available.  This is the release that breaks backward compatibility in order to get rid of some warts—not enough and not enough for some people, but it’s still a big step forward for the languages.  Kudos to all involved.

Summer 2007 Post Mortem

We held the post-mortem for the summer’s projects yesterday. It went well—the summer, I mean, not just the post-mortem. Here are the main points:

Good Bad
  • Industry/prof visits
  • Learned a lot (group work)
  • Learning the internals of a large system
  • Making friends
  • Excellent office space
  • Learned that software engineering can actually be interesting
  • Doing something new (building real code!)
  • Martin + Tony worked independently very well
  • Had a good OLM deployment plan
  • No personality clashes
  • Good data model for new ticketing system
  • Group lunches
  • Speed Scrabble
  • Python
  • Learning (self-)discipline
  • The Google podcast
  • Self-administration of machines (fun to do, fun to learn)
  • Hardware was good
  • Regular status meetings were useful and a good learning experience
  • OLM testing
  • Talk with Jay Goldman
  • Sharing problems on the mailing list
  • Jeff Balogh’s visit
  • We did it!
  • Working solo on UTest
  • Dealing with Ant
  • Falling behind on collaboration with partner
  • No real time plan for the last month (before deployment)
  • Hardware problems that were never resolved
  • No contact with previous teams
  • Python and Eclipse
  • Too much time spent in email
  • Supervisors were too hands off
  • Didn’t get deployed on schedule
  • Didn’t get in the habit of “talking tickets”
  • Status meetings didn’t turn in to design meetings
  • Interface to new ticketing system
  • Greg’s absence (length and timing)
  • The old dashboard code
  • Should have had bi-weekly demos
  • Initial nervousness (a.k.a. “startup shakes”)
  • Having meetings at 9:00 AM
  • Not enough documentation (but we haven’t done any better)
  • Supervisors couldn’t cover for each other during absences

Random Survey about HPC

This was just forwarded by a friend:

The High Performance Computing (HPC) community is initiating a study to develop education and training pathways in order to enable scientists and engineers to advance the pace of discovery by taking advantage of high performance computing (HPC) and grids.

In order to inform our study, we invite you to complete a survey about your experiences. We would like you to evaluate a list of categories of expertise according to how relevant they are for your work. We also would like to collect additional information about your training experiences.

The survey is very short and should only take a few minutes to complete.

Please go to the following link to complete the survey: http://www.surveymonkey.com/s.aspx?sm=_2f7D2YUJfkH9Dua0PP_2f30_2fQ_3d_3d.

The survey will be open for input through September 11, 2007.

Your input is very valuable to us and will help us understand your training needs.

Thank you for your participation in this study!

Scott Lathrop
TeraGrid Director of Education, Outreach and Training – www.teragrid.org
SC07 Education Program Chair – www.sc-education.org

The questions seemed pretty random/subject to broad interpretation, but I filled it in anyway—I’ll be interested to see what if anything comes of it.

Seven Right, One Very Wrong

Paul Graham recently posted a piece titled “Holding a Program in One’s Head”. His argument is that, “…it’s only when you have the code in your head that you really understand the problem,” which I agree with. He then goes on to list eight things you can do to achieve this goal, one of which is just plain wrong:

Don’t have multiple people editing the same piece of code. You never understand other people’s code as well as your own. No matter how thoroughly you’ve read it, you’ve only read it, not written it. So if a piece of code is written by multiple authors, none of them understand it as well as a single author would.
And of course you can’t safely redesign something other people are working on. It’s not just that you’d have to ask permission. You don’t even let yourself think of such things. Redesigning code with several authors is like changing laws; redesigning code you alone control is like seeing the other interpretation of an ambiguous image.

If you want to put several people to work on a project, divide it into components and give each to one person.

Everybody’s had the experience of wrestling with a bug for hours, then having the solution leap out at them when they’re three sentences into explaining it to someone else.  Co-authoring code is, I believe, the best way to understand it and the problem it’s supposed to solve, just as teaching is the best way to actually learn something.  Gerry Weinberg knew this thirty-five years ago when he talked about egoless programming;I guess it’s a point that needs to be re-made constantly.

The Sunlight Foundation and Hosted Lifebits

Jon Udell has posted a conversation with Greg Elin about the Sunlight Foundation, whose goal is to make the workings of government more transparent and accessible. Interesting quote from Elin:

I increasingly feel that the reason for Congressional hearings to be open and recorded and annotated is market efficiency. The fed does not announce what it’s going to do with interest rates until it announces it to everybody. But is that the case for the rest of Congress and legislation? If I can afford to have a fulltime lobbyist going to the committee meetings, don’t I have an inside track?

In a separate post, Jon talks about the idea of “hosted lifebits” as the endpoint (well, an endpoint) in the evolution of social software.  His book Practical Internet Groupware was years ahead of its time — if you’re young, ambitious, and want to know where the kitchen is, you could hardly do better than to dig into this stuff.