Antonio Rodriguez

Antonio Rodriguez has been in software industry since 1996, having spent his entire career working on Internet related gigs. Most recently, he was CTO of HP's consumer imaging and printing business where he worked on a wide array of projects: from mass customization to making the web more "printable," to e-reading, to mobile platforms.

He came to HP through the acquisition of a company he founded in 2005, Tabblo, which aimed to make the world a more beautiful place by giving regular users the tools and software assistance required to publish photos and text in compelling formats worthy of publishing.

Before Tabblo, Rodriguez has held a number of engineering, product, and management roles other startups and large companies, all targeting regular folks with tools and services offered over the Internet. Through those experiences, he has come to have a deep appreciation for the tools and processes (most prevalent in thriving open source communities) which enable collaborative iterative development, and in the best of cases, a symbiotic relationship between hackers and users, makers and customers.

Rodriguez has been happily using Python since 2001 when a giant consumer electronics customer with an insane demo timeline forced him in search of something better than distributed Java. After building twice what the customer wanted in half the time, he never looked back.

Mark Shuttleworth

Mark is founder of the Ubuntu Project, an enterprise Linux distribution that is freely available worldwide and has both cutting-edge desktop and enterprise server editions, and has become very popular.

Mark studied finance and information technology at the University of Cape Town, and went on to found Thawte, a company specialising in digital certificates and cryptography. He sold Thawte to US company VeriSign in 1999, and founded HBD Venture Capital and The Shuttleworth Foundation. He moved to London in 2001, and began preparing for the First African in Space mission, training in Star City, Russia, and Khazakstan. In April 2002 Mark flew in space, as a cosmonaut member of the crew of Soyuz mission TM34 to the International Space Station. In early 2004 he founded the Ubuntu project, which aims to produce a free, high quality desktop OS for everybody.

Deployment, development, packaging, and a little bit of the cloud - Ian Bicking

In this opinionated talk Ian will discuss his thoughts on packaging, web application deployment, configuration, tools to manage environments across both development and production, the tensions between Linux packaging and Python packaging, just a little about virtualenv, pip, buildout, and Distribute, and a bit more about a new tool toppcloud, and the modest but important role cloud computing has in this process.

This talk will not be "instructional," in that you will not know how to do things you did not previously know by attending this talk. Rather it will describe problems, motivations, and what the speaker thinks are positive directions, and what he thinks might be dead ends.

Some of the questions the speaker thinks about:

• What happens when you type "python"
• How do you run tests?
• How do you give other people your code?
• How do you track both intended and unintended aspects of your environment
• How should the files be laid out
• Letting sleeping dogs lie: don't break stuff that runs
• What balance should you strike between environment flexibility and consistency
• Is the context the environment or callstack?
• Processes or threads?
• The I-can't-claim-it's-not-necessary-but-I-wish-I-could job of system administration
• Who deploys stuff, sysadmins or developers?
• Appropriate avenues for pushback
• Distributed version control vs a consistent world view
• Monkeypatching vs. source patching
• What is cloud computing?
• Why are there so many cloud computing pundits, and why can't I understand them?
• The hating of hardware
• The economics of free (beer or speech) source and not-free computing

Interfaces, Adapters and Factories - Jeff Rush

A step-by-step introduction to the idea of object interfaces and adapters using incremental code examples, based on the zope.interface module. The case for adaption to ease code brittleness will be made and how we can reason about interfaces. I'll show how to automatically check code for conformance to your interfaces and then cover where objects come from, the several kinds of object factories in Python and how one kind can be based on interfaces.

Python's Dusty Corners - Jack Diederich

The talk will be a brief overview of all the features in python that you don't need to know about right up until the moment you do. The list includes how comparisons work, descriptors, iterators, context managers, namespaces, else clauses on for/while loops (suggested by Hettinger). The narrative of the talk is that these are features that you don't need and/or shouldn't use in your day-to-day code but that you need to keep in the back of your mind because other people's code and the stdlib do use them. As Alex Martelli pointed out in his wonderful talk "Abstractions as Leverage" you can't successfully function at one level of abstraction if you don't know what is going on at the next level down. This talk is a whirlwind tour of the next level down.

Debating 'til Dawn: Topics to keep you up all night - Mike Fletcher

PyCon is about staying up all night hacking. When you're tired, you don't sleep, you debate ideas with your sprint-mates! This presentation will attempt to condense the best of the last few years of PyGTA into a 30-minute jumping off point full of wild assertions, unreasonable assumptions, and just plain wrong-headed ideas to kick-start those heated discussions that just keep going long into the night. What are your programming mantras? What million-dollar ideas do you have to improve Python? Should there be programmer liability? Is there art in programming and should there be? Are you a cowboy coder or an straight-laced engineer? Is PyCon really about staying up all night discussing ideas? We'll have a feedback channel to share your thoughts, we'll keep it moving, and we'll see if we can't make this the most sleepless PyCon yet.

Mastering Team Play: Four powerful examples of composing Python tools - Raymond Hettinger

Starts with a quick review of the performance characteristics of major individual tools in Python: bisect, heapq, lists, deques, sets, frozensets, class structures, sorts, and weakreferences. Show how these tools can be powerfully combined to create elegant solutions to four hard problems.

1. Random sampling: when one data structure isn't enough. Discuss how the nature of the problem dictates when to use one of two alternate data structures.
2. Ordered dictionaries: with the right compostion of dictionaries, linked lists, and weak references, a dictionary can remember its insertion order without any impact on its big-Oh running times.
3. NFA to DFA conversion. The classic, but difficult, algorithm for lexical analysis becomes simple when composing Python's dicts and frozensets.
4. Running median: the obvious approaches are horribly slow. The problem centers around how to efficiently maintain sorted data while advancing a large sliding window one value at a time. A list of deques provides a dramatic and scalable improvement in running time.

The other kind of testing - Bob Ippolito

Software testing helps verify that your code meets a specification, but not how to improve the specification. How can you stay competitive when most of the big names today are using analysis to guide product evolution? Level the playing field and make better products by learning how to design experiments, collect data, make measurements, and optimize your specifications.

Powerful Pythonic Patterns - Alex Martelli

An extremely misguided meme is going around: that Python doesn't have, or need, any Design Patterns. Maybe the meme springs from not realizing what the Gang Of Four state so plainly in their historical "Design Patterns" book: which design patterns are useful DOES depend on the programming language one targets -- design is NOT independent of implementation, as the epic-fail "Waterfall" Methodology Pattern would suggest. If you examine a "classic DP" that's basically a workaround for some other language's lack of garbage collection, or for a clumsy static-typing system, it may indeed be worthless for Python. But many other DPs are still perfectly useful and applicable, and indeed Python's strengths as a language afford riffing on them to develop highly Pythonic, powerful, productive variants.

In this talk, I analyze some of my favorite pattern families -- e.g., Template Method and its variants, Dependency Injection and its ilk, Callback and friends -- in a highly Pythonic context. Non-pattern Idioms, and Patterns that aren't really Design Patterns but rather Architecture or Methodology ones, also make cameo appearances.

Threading is not a model - Joe Gregorio

We have many concurrency/multiprocessing capabilities at our finger tips, such as threads, processes, locks, mutexes, select, epoll, transactional memory, etc. But none of them are a model for multiprocessing, they are only tools on which you would build an implementation of such a model. So what are the models we can choose from? How would they be implemented in Python? And why may the GIL actually be a good thing?

Tests and Testability - Ned Batchelder

Testing software is difficult. Large complex systems don't lend themselves naturally to automated testing. This isn't just because they are large, it's because developers often don't consider how testable their code is. Testability is as important as all the other -ilities in your code (portability, maintainability, efficiency, etc).

Testability is a characteristic of your code that makes it easier to test. Increased testability can give you better tests, but it also gives you just plain better code. Improving testability generally means considering the interfaces to your internal modules and improving them to provide better modularity. This improvement often has benefits in your product code.

I'll discuss specific examples to demonstrate how code can be made more testable. Mocks, dependency injection, and crisp API design are just a few of the techniques that can improve your code's testability and make you a happier person.

The Ring of Python - Holger Krekel

CPython 2.5/2.6/3.1, Jython, IronPython, PyPy, StacklessPython, UnladenSwallow, Cython ... what do we make of all these cool interpreter projects and versions? Where does competition help and where does it hamper?

In this interactive talk I'll highlight the main strengths of each of the Python interpreters. Furthermore, I'll discuss ways to leverage Python interpreters in a co-operative way, discuss challenges, projects and issues ahead and also briefly highlight 'execnet', one my own projects for bridging (Any) Python to (Any) Python. This is also the first time i am going to try out a new and funvisual presentation technique after several years of having done mostly text-based ones