ShootQ is a web-based studio management solution for professional photography studios, designed to automate and simplify the task of running a small business. In this talk, Jonathan LaCour, the CTO of ShootQ, hopes to share his experience designing a web application that can scale up to meet the demands of a rapidly growing customer base. The talk will cover a variety of topics including TurboGears 2.0, WSGI, horizontal and vertical scaling, database replication, load balancing, deployment, and more.

An examination of the ways Python is being embedded and deployed in the large applications used for computer graphics; like Renderman, Maya, Houdini, and Nuke.
 
This session is for those interested in the popular techniques of embedding the Python interpreter. The survey will determine the best practices for embedding Python at the core of a large application.

Create distributed code that communicates trivially over the network with objects that answer as if they were local.
 
Send, receive and manage data with this powerful library. Presentation will include real life example for restarting
a load balanced web instance running two Apache web servers and a MySQL database.
 
Although Python allows you to perform simple network operations, Pyro creates a nice layer between core networking
essentials and your code, allowing you to concentrate more in developing your application.
 
   
 

Since Python 2.3, the ability has existed to customize the import process so that one can support code stored in alternative formats, e.g. zipimport and its support of importing code from a zip file. The aim of this talk is to make sure you understand how the custom import mechanism works and how to write your own custom importers using importlib from Python 3.1.

Twisted is a framework for building asynchronous networking applications. It also provides powerful tools for writing non-blocking non-network code, tools which are vital for building real large scale applications in Twisted. I hope to give a comprehensive overview of these tools to help the intermediate Twisted user get things done concurrently.

Leveraging the power of Python, military analyst and software developers out at White Sands Missile Range in New Mexico have converted a closed-form model, which was developed for scripted Cold War scenarios, into a more sophisticated and adaptive system. COMBATXXI is a premium wargaming model, which now is poised to answer questions that have a direct effect on military operations currently in theater, in large part because of Python.

Pinax (http://pinaxproject.com) is a platform built on top of Django (http://djangoproject) for rapidly developing websites. This tutorial will show you how to install Pinax, create a project, work with a Group application and a Group Aware application, and finally how easy it is to modify templates.

Roy Fielding described REST in his Ph.D. dissertation in the year 2000. Almost ten years later, Web developers are still confused as to how to apply the REST principles in their applications. Examples of poorly designed 'REST' APIs abound, and I will make use of them in my talk.
 
In this presentation, I will give an overview of REST and its design principles, and I will show a concrete example of a RESTful Web service implemented in the restish framework. My examples will include CRUD operations, as well as transactions. I will also show how to consume this Web service using both httplib2 and curl. I would be remiss if I didn't describe ways to test the Web service with WebTest and twill.

It is now possible to develop feature rich GIS web applications using TurboGears by harnessing the power of spatial databases using GeoAlchemy and integrating python GIS frameworks & utilities with TurboGears using tgext.geo

It seems that almost every python web framework in existence has solved the problem of automatically generating forms. Some have straight forward techniques, some are unique or even an unusual approach to the problem. The question is: "what can we learn from each other?". This panel will examine the different ways developers generate forms by offering examples, and summarizing the functionality, differences, and similarities between these valuable web development tools.

Caching, replication, partitioning, and distributed databases: how these can (and can't!) help you scale your data.

Websites are getting increasingly dynamic and realtime in order to compete with desktop applications. This talk is an examination of 3 websites/tools I've built, all using Python. I'm going to try to explain what we did to build these, and how you can do the same.

WHO ELSE wants to write better code with fewer bugs, *faster*? This is the promise of automated tests. But the knowledge and insight for *rapidly* crafting powerful, maintainable tests is not obvious. This talk helps launch you over that learning curve: forms of unit and automated tests most effective for Python code. You'll learn: important, foundational idioms and design patterns for your testing toolbox; writing maintainable tests you can understand a year later; leveraging parametrized tests; and finally, exploiting uncommon features of Python, such as first-class functions and closures, to create concisely powerful test cases not possible in most languages.

A brief introduction to modeling and solving resource allocation and scheduling problems using Python and SCIP.
 
At times a programmer is faced with difficult, possibly NP-Hard, optimization problems such as scheduling or assignment. Sophisticated techniques exist for modeling and solving these sorts of problems which are well implemented in optimization solvers. This talk introduces some of these techniques using the ZIB Optimization Suite and its new Python interface.

CPython mostly gets faster from one version to the next. And when CPython gets faster, your programs get faster. This talk is a survey of optimizations made to CPython, recent and historical, large and small. Audience doesn't need to be familiar with CPython internals, but should be familiar with Python and conversant in C.

These days, there are countless number of software applications and web services that have been developed using free and open source software (FOSS). Such tools have become so flexible, powerful, and universal, that it should also be possible for authors to write manuscripts using open source tools like Python in the same way that applications are developed. In this talk, we present some case studies of this phenomenon.

In mid-2009, SourceForge embarked on a quest to modernize our websites, starting with the download (consumer) flow on SourceForge.net. A small team was tasked the rewrite, converting a site originally implemented in PHP with Python. Using a customized TurboGears as a core component, the rewrite was completed and the new site deployed in under 2 months. This talk tells the story of that rewrite and explains our new technology stack, which includes TurboGears, MongoDB, and Jinja templates.

SUMMARY
This talk is about the evolution of Python. We will discuss Python 2 and Python 3: what the compatibility issues are, what the main differences are, and also talk about migration, Python 2.6, and other transition tools.

The PSF recently adopted a diversity statement. While some argue that we should do this just because it's "the right thing to do", others question why we, as a technical community, should even worry about diversity. This talk addresses the diversity question, not in moralistic or ethical terms, but in pragmatic ones. Studies on creativity and productivity demonstrate the potential benefits of diversity for the Python community. Making Python the best language it can be is not merely helped by increasing diversity, but may be dependent on diversity.

Story of a refactoring I did to split one big, monolithic Pylons app into a bunch of smaller ones, using power of WSGI and nginx. The devil is in the details: how to handle common auth, site-wide look&feel, common utilities, database management. Pros and cons of the approach, possible alternatives.
 
The talk assumes listeners know what WSGI is and preferably have used some WSGI-centeredframework like Pylons, Werkzeug, Paste or other.
 
The application this talk describes powers developers.org.ua.

In Python 2.7 and 3.2 a whole bunch of improvements to unittest will arrive. unittest is the Python standard library testing framework and for several years it has languished whilst other Python testing frameworks have innovated. Some of the best innovations have made their way into unittest which has had quite a renovation.
 
This talk will go through the major changes, like the new assert methods, test discovery and the load_tests protocol, and also explain how they can be used with earlier versions of Python.

Both newcomers and experienced developers alike love Python's built-in data types — especially dictionaries! But how do dictionaries work? What do they do better than other container types, and where, on the other hand, are their weaknesses? Using simple, vivid diagrams that show the secrets of how the dictionary is implemented, and a series of progressively interesting examples of its behavior, we will train the Python developer's mind to picture what the dictionary is doing in just enough detail to make good decisions, as your data sets get larger, about when to use dictionaries and when other data structures might be more appropriate.

The rise of WebFaction has been dramatic in the world of Python-friendly hosting services. What are the secrets to getting the most out of their features? From the point of view of a customer with no other affiliation with WebFaction — as a customer advising other customers — this talk offers lessons learned in using WebFaction to host everything from lone static content to multiple Python web applications and services co-existing together. WebFaction uses some unique techniques to support both user-local *and* application-local Python packages. Should you use their special installation techniques, or install and use virtualenv on your own initiative? Learn the trade-offs, and learn how *not* to get yourself in trouble while running ``easy_install`` on WebFaction, my favorite hosting service.

Gordon Bell's observation that "The cheapest, fastest and most reliable components of a computer system are those that aren't there" has a parallel in data structures. The fastest, most parsimonious, and best performing data structure is one which is never concretized within a program run. A promise to create data when, or if, it is needed is often easy to make without needing to realize the data computationally.
 
The addition of iterators and generators to Python during the 2.x series, and their more systematic use in 3.x, provides an easy way to work with lazy computation. Using these facilities well can improve program performance, often in terms of big-O complexity even. However, sometimes more complex lazy data structures require special design in order to encapsulate more complex promises than one can make with list-like iterators.

An incremental deconstruction of a class definition identifying the key elements
such as layered namespaces, common attributes, lifecycle and access controls.
We'll also look at calling into, out of and through an object, making classes
extensible and various object behaviors like containment, sequence, iteration
and arithmetic.

The Python Package Index (PyPI) became over the last years an essential tool to share your Python programs. As long as you use Distutils standards, you can register and upload your work at PyPI in a few seconds.
 
Projects like Setuptools and Pip added great features on the top of this : the ability to fetch PyPI to install a project and its dependencies. So you can "easy_install A-Program" and everything is done automatically for you.
 
But all these features have shown the flaws and limitations of the current Distutils design, and the urgency to make it evolve with respect to the existing OS-specific packaging systems.
 
This talk will detail the biggest issues that need to be solved, and the work that is being done. It will end up with a presentation of the Distutils roadmap, and an overview of the Distribute project, the Setuptools replacer.

Python makes a great metaprogramming languages. Metaprogramming is great for solving problems faster, in a more generic way and providing rich APIs. This talk explores the different options provided in python to do metaprogramming and the right way to use them.

Jython is an implementation of Python for the JVM. This talk covers the options available for integrating Jython and Java code, especially Java calling into Jython, since this is the trickier case. This talk will also cover some Java specific deployment options, such as deploying your Jython application as a jar file. Jar files allow you to package Java/Jython applications into a single archive. In many environments a user can click on a jar file to launch the contained application.

Summary: One of the most popular requests for the IronPython team is tooling support. During this talk I’ll show you some of the existing tools available to help create IronPython applications. I’ll also look at the latest IronPython features which can help you debug, profile and improve your applications. I’ll also compare and contrast these with the solutions available for CPython that you may already be familiar with.

You write your server code in Python because you want to. You write your browser code in JavaScript because you have to. But with IronPython and Silverlight, you can write your browser code in Python and leave JavaScript behind. This talk provides an overview of Silverlight for Python developers, including out of browser applications as well as the new “just text” model where Python code is embedded directly in HTML pages. Even if you develop on Linux or Mac, you can still take advantage of Silverlight in the browser

Unladen Swallow is a Google-sponsored optimization branch of CPython. This talk will cover Google's motivation for Unladen Swallow, the approach being taken, results so far, challenges faced, cancers cured and plans for merger with CPython.

Internationalizing your Django application isn't as hard as it sounds. This session introduces the topic of internationalization and walks through what it takes to use Django's internationalization tools, including how to mark models, views, and templates for translation and how to enable internationalization in your application. We will also step through localizing your application in a new language.

Even though we are Python lovers, we at PythOnRio (Python's Rio de Janeiro users group) strongly believe in differences. Programming languages and technologies are not religions. Why do we have to compete against each other when we can take advantage of diversity by sharing our knowledge and learning to use the best tools for each job? By promoting this thinking we are gathering people from many different open source communities.
 
That's our main recipe for the success of initiatives like Coding Dojo Rio, PythOnCampus, Dev in Rio, #horaextra and many other social meetings where we have gathered some of the smartest people in Rio's software development community.
 
With this philosophy, Rio de Janeiro communities are growing and starting to jell - they are becoming so strongly knit that the whole is greater than the sum of the parts.
 
In this talk, we would like to share not only our "methods" and "formulas", but the values and experiences that are leading us to build a strong and active community while having lots of fun.

Everybody has internet. Everybody knows what is a CableModem, but Does anybody knows how does those devices works ?
this talks shows a new network traffic simulator developed while developing a DHCP server. First, we will talk about devices such as Cablemodems or CMTS,
showing how easy is to simulate as many "virtual devices" as we want, and the familly of protocols already implemented. Later , will show how easy
is to add new netowrk devices ( such as Wimax, EMTAs, etc) and new protocols. Allowing to simulate and play with any "virtual device".

Or, "how we cut 40,000 lines of code and learned to love unit testing."
 
This talk will cover some of the development history behind Ellington,
the CMS which spawned the open-source Django web framework, and some
of the issues involved in developing and maintaining a codebase of
this age and size. Highlights include branch management, the
advantages of open-sourcing non-critical functionality, the pain of
porting and the joy that can only be found in a passing test suite.

Want to rapidly test code, javascript or documents on different Python Interpreters and versions? This talk gives an overview on new py.test features of the last year. I'll discuss the minimal-boilerplate testing and new plugin model and give an overview on which testing needs are covered so far, for example:
 
* run tests written for nose or unittest
* ad-hoc distribute tests to local or remote Python environments
* test compatibility with Python3
* run javascript unit-tests in real browsers
* coverage testing
* django-specific testing
 
I'll conclude with upcoming features regarding testing-in-the-cloud and plans on more test tool convergence. (URL: http://pytest.org)

The Python Global Interpreter Lock (GIL) is a frequent source of debate and concern for programmers working with threads and concurrency. Although most Python programmers generally know that the GIL restricts Python's ability to utilize multiple CPUs, few know the inner details of how it actually works and how it impacts applications. This talk will dive into the inner workings of the GIL like you've never seen before. Topics include details about the execution of the Python interpreter, thread implementation, the GILs surprising behavior on multicore CPUs, and more.

The first part of the talk will cover PyPy's speed achievements resulting
from the last year's work on the Just-In-Time Compiler. I'll present
and discuss a number of benchmarks and compare against other Python-speed
projects. I'll also cover the basics of how the JIT works and what
sort of programs it can greatly speedup (and which ones it can't).

A whirlwind tour of the roles of different Python modules in the architecture of a geospatial infrastructure planning system.
 
We used Python to transform an elaborate, multistep process for finding and connecting households in villages into a single, streamlined planning experience. I'll explain how Python's freely available libraries empowered a small team of developers under a minimal budget and timeframe. Now just imagine if we had to do the same thing with Java.

Since September 2008, teams of undergraduates from half a dozen different universities have been building a Django-based replacement for Trac called Basie. This talk will present what they've accomplished and discuss what we've learned about getting junior developers who are juggling half a dozen projects at once to build production-quality code.

At CCP Games (www.ccpgames.com), we work on large MMO projects with tens of content editors editing the same data. To make this possible, we created a Revisioned Database framework that allows for us to create new multiuser editing systems without data synchronization between users having to be a major concern. In this talk, solutions we've tried are discussed, the basic layout of our revision database shown, the Python layer which handles it transparently for the programmer detailed, and how the Python layer is used in practice. All of this is focused on discussing what worked well and what pitfalls we ran into during development.

Why chose Python to teach compilers?
 
In the University of Applied Sciences ARC, compilers are taught in a relatively short amount of time. Focus is put on the main conceptual ideas, letting aside many technical details. Still, the students are expected to write a full compiler within a few weeks' time
After trying the traditional C/Lex/Yacc based approach, and a more education-oriented Java/Jaccie solution, we settled on Python and PLY, plus a few enhancements (syntax tree graphical representation, decorator to achieve better code separation).
As a result, the students get a better understanding of the compiler concepts and produce more interesting and creative projects.

Got a text parsing problem? In most cases using string manipulation and regular expressions will solve it for you. But when the input is complex, try reaching for a parsing system to help out.
 
The two most popular in Python are PLY and PyParsing. PLY follows the lex/yacc tradition with a domain specific language to describe the tokens and grammar. It was built with both error diagnostics and performance in mind. PyParsing is a recursive descent parser which expresses the format as a Python data structure. It make no distinction between lexer and grammar and has a uniform callback system which makes certain types of data extraction very easy.
 
In my talk I'll show the basics of how to use both systems for several different format parsing tasks, of different complexity. This will let you see how to use the parsers and understand more of the tradeoffs between complexity, readability, error handling, and performance.

Agent Based Modeling and Simulation is an approach for studying complex systems
as collections of of independent, interacting agents. Swarm is perhaps the leading
framework and protocol for Agent Based Modeling and has been implemented in several
languages, most recently Python. In this talk we will explore simulation,
Agent Based Models, the Python implementation of Swarm, and a sample modeling problem.
 

The PyUnit (unittest) unit testing framework provides an easy-to-use set of tools and techniques to add robust unit testing to your Python code. By integrating unit testing in their code, developers allow for a robust set of tools to quickly and easily identify "broken" code.
 
In this session we'll explore the unittest module and demonstrate how to leverage PyUnit for unit testing.

There is a lot of buzz about Couch, Casandra, MongoDB, and other non relational databases, and at the same time there are decades of hard work that's gone into optimizing databases built around the relational model. This talk will focus on comparing relational DB's to their new friends in practice, and on providing practical tools for deciding what's right for your project.

This talk will cover basics about writing cross-interpreter
python programs. What to do and most of all what not to do.
This will help you if you want at some point in time to
run program on for example Java platform or faster python
interpreter, but also if you want to keep it running between
CPython releases.

How do you enable others to easily extend your libraries or your frameworks? If you have a large, complex application like Canonical's Launchpad software collaboration platform (https://launchpad.net/), how do you keep the interconnecting parts cleanly, separately factored while still enabling sophisticated interactions between them? Over five years ago, the Launchpad web application was one of the first projects to use the patterns and implementations from the "Zope Toolkit" libraries (née Zope 3) to address these problems. These powerful ideas can effectively provide pluggable singletons, pluggable functions, pluggable classes, and pluggable casting on the basis of objects' classes or interfaces. They have worked out well, with some caveats. I'll explain the ideas. Then we have some ideas to share on how to apply these patterns, how we might retool the core Zope Toolkit libraries to address our pain points, and how we are integrating some of these ideas and libraries into other projects, such as web applications that use Django.

We describe how Python is used in a large astronomy project to automatically process data from several telescopes in both the hemispheres. We introduce the general problem and discuss challenges and lessons learned.

This presentation gives an overview of how packages are build and
distributed for different operating systems in the Enthought Python
Distribution. Enstaller (http://pypi.python.org/pypi/Enstaller/4.0.0)
is a tool I wrote for installing egg-based packages, which are not
necessarily Python packages, such as SWIG or HDF5. I will discuss
the architecture of Enstaller, and in particular the egg-based distribution
format.

CherryPy will be 8 years old in June 2010! This presentation will look at the "Zen of CherryPy": a set of 10 design guidelines which CherryPy has developed over those years, explaining why they're useful, why some are uniquely Python, and how to apply them in your own projects.

In this talk, I'd like to talk a bit about Mercurial. This will not be a beginner-level talk on DVCS or hg; it aims to be a higher-level discussion of the concepts employed in Mercurial. After having discussed these, I'd also like to compare Mercurial and git based on UI, performance and underlying concepts.

You think Python gives you native cross platform applications for free? Think twice.
Are you interested in distributing your application to other platforms but not sure how?
 
We will give tips and examples on how to enhance the native feel of your application: notifications, registration of file types and more. The talk will also help you to avoid common pitfalls and provides solutions for designing cross platform user interfaces. (Although we use wxPython as an example, the principles are valid for other toolkits as well.) We'll show you where to start if you want to distribute your application to different platforms, briefly discussing tools like py2exe, py2app and Debian/Ubuntu packaging ecosystem. This talk is based on our experience from developing Phatch (Photo Batch Processor) and SPE (Python Editor).

Advanced string formatting (str.format, described in PEP 3101) was added in Python 2.6 and 3.0 as a more powerful, flexible, and extensible alternative to the existing %-based string formatting.
 
This talk will discuss how to use str.format, how your own types can benefit from it, its strengths and weaknesses, how to migrate to it, and advanced topics such as implementing your own templating language.

Thinking about scoring a government contract, but haven't heard of 508 compliance yet? Interested in making your site accessible to people with disabilities? Never thought about compliance, but want to know why it's a good idea?

A practical look at NLTK and Dumbo, python-powered and open-source toolkits and APIs for processing natural language on a large scale.
 
For people like us who make a living trying to make a computer "understand" human language, Python is a very powerful language, given its rapid prototyping abilities, native unicode support and a stellar standard library. This relationship has been strengthened further by an open-source, python-based Natural Language ToolKit (www.nltk.org) which is being widely used in the community for both teaching and research purposes and gaining traction in the general Python community as well (www.nltk.org/book). Recently, the Python community has seen the release of Dumbo (http://wiki.github.com/klbostee/dumbo), an open-source, python-based cloud-computing API (based on Hadoop) via the hands of Klaas Bosteels.
 
In this talk, we show how the amalgamation of Python, NLTK and Dumbo can allow for very large-scale natural language processing efficiently and elegantly.

For over a year, HackLabTO (http://hacklab.to), a hackerspace in Toronto, has been the home of an informal Python class / hack night every Thursday evening. Our participants represent a diverse cross-section of the lab's community, and include everyone from complete beginners who hadn't written code since BASIC in high school, to seasoned veterans. Come hear about our successes and failures, and learn how to start such an event in your local community.

I have been wanting to learn about audio processing because I'd eventually like to write a simple DJing application. What better way to explore some intermediate level programming concepts, as well as an interesting media library (PyMedia), than by doing it in Python. This talk covers what I learned on my way to creating a console-based skeleton of a DJing application with the intention of later returning to add a GUI on top.

There are so many great open source databases out on the market right now--
we're really in the golden age of databases. Fortunately, Python can talk to
virtually all of them. With so many databases at our disposal, how do we
choose which one to use for our particular use case?
 
This talk will go over the many different classes of databases, introduce some
of the particular implementations for each class of database, and describe the
strengths and weaknesses of each. By weighing the pros and cons of each type
of database, the speaker hopes to dispel the many rumors and misconceptions
that people have about what's out there today.

LOLapps is one of the top providers of social games and user generated applications with 50+ million monthly uniques on Facebook, MySpace and Bebo. This session will focus on the top-down approach we took to scale our webapps for millions of users. Here are the 6 topics we will cover:
 
- Why is performance a big issue for Social Media
- How we profiled our apps and found bottlenecks using custom developed and existing middleware
- The web application best practices we applied and results obtained
- How we traced database connection leaks
- Our caching strategies and the changes we made to speed up the memcache client
- Results of our experiment using Paster and Tornado as our web servers.

If you've been using Django for any amount of time, you've probably learned
some pretty standard practices on how to use it. This talk aims to shatter
those conceptions and teach you alternative ways that you could use Django.
 
These alternate ways come broadly in two varieties: Using parts of Django
outside of it, and choosing alternatives to what Django offers. If you haven't
done either of these things before, it may seem tricky or difficult. In fact,
it may not be. This talk will walk you through the process and talk about what
to expect if your project just doesn't seem to "fit the mold".

Sprox is a web frontend tool build to handle the creation and manipulation of data.
 
Sprox is smart about your data. You should never write repetitive code again. Sane defaults and easy overwrites is what makes Sprox guess what you need for your fields.
 
This talk will give an overview of Sprox, what it does and how to use it. Then we'll explore the available backends (SQLAlchemy, MongoDB) and dive into the tgext.admin package, which is the "Admin Tool" for the TurboGears2 framework.

Decorators simplify design and improve readability and reliability. This tutorial starts from the beginning with basic decorators, showing how simple tasks like restricting administration functions are clearer and more readable with decorators, and exactly how the decorators work. A simple library of decorators for tracing, logging, and caching results is presented. This leads into writing your own decorators and parameterized decorators either from scratch or by using libraries like Simionato's Decorator Decorator and "@call_before(fn)". Finally, using Python 3.x class decorators in place of metaclasses for most common dictionary modifications is covered.

Databases that employ a data model other than the relational model are increasingly a hot topic. Neo4j is an open source database where the data model is a graph. Data in Neo4j is stored as Nodes and Relationships in between nodes. A lot of the data we model in applications every day is actually graph oriented, having a database that persists such data natively is a huge benefit. In this presentation we will see how to use Neo4j in Python, and demonstrate this with a web application in Django.

Network servers which scale to thousands of simultaneous connections have always been possible in Python thanks to libraries such as asyncore and twisted. More recently, FriendFeed's new open source project Tornado has stirred debate in this area. These libraries allow a Python process to scale to many simultaneous connections using non-blocking I/O (also known as asynchronous I/O). However these projects require that the programmer learn a custom API to abstract away the complexities of using a callback-style API.
 
Eventlet uses greenlet, which provides coroutines as described in "The Art of Computer Programming", to implement efficient cooperative concurrency while retaining synchronous semantics. Eventlet also provides an implementation of the standard library's socket module. Code written to use Python's standard socket library can be transparently converted to use nonblocking I/O and green threads with eventlet. This leads to much greater code reuse and programmer efficiency.
 
http://www.eventlet.net/

The world of open source ecommerce is dominated by PHP-based solutions. However, in the past few years, there has been significant progress in building robust python-based alternatives. This discussion will cover 2 different python approaches. Satchmo is based on the Django framework and GetPaid is a framework for credit card processing in Plone. These solutions share a similar philosophy and approach but can be used in very different ways. This discussion will increase awareness of these applications, feature successful projects, explain how they can be used in your projects, and help you connect with the open source community.

Pynie is an implementation of Python 3 on Parrot. The goal of Pynie is to duplicate the pure-Python behavior of CPython 3.x, and perhaps eventually a C API compatibility layer. Parrot provides a set of compiler tools and core functionality common to many dynamic languages, so the core code of Pynie is lightweight. Pynie allows Python 3 libraries to be shared between multiple languages. This talk is an overview of the features Pynie currently supports and the work left to be done, together with an introduction to the internals of Pynie.

Writing frameworks is fun, which is why we have so many of them in the Python web development world. Making your shiny new framework stand up under the load of a demanding application can be painful, but can lead to substantial improvements.

Salesforce.com is a leading provider of Customer Relationship Management (CRM) for enterprises (over 55,000 customers) and nonprofits (over 6,000 customers). While it handles sales, marketing and support processes, it can be extended to automate any business process, making it a core part of business operations. Python developers working with companies using salesforce.com need to be able to integrate applications with Salesforce. Luckily, Salesforce.com has an elegant and powerful SOAP API. This presentation will introduce an example of using the Python wrapper for the Salesforce.com API (Beatbox) in an interactive website. While the library itself is powerful and can be used in custom Python applications, the Python community can also leverage the advanced integration between the Plone Content Management System (CMS) and salesforce.com. We will demonstrate how a Plone website can post forms, ecommerce transactions, and event RSVPs to salesforce. Additionally, we will show how developers can make Salesforce.com data interactive in a Plone website.

The Python Standard Library's cmd module makes it absurdly simple to write command-line interpreters - non-graphical programs that communicate with users interactively through a simple text interface. The third-party cmd2 module adds high-powered "batteries" to applications written for cmd.
 
This presentation teaches attendees how to easily make their own powerful command-line interpreters with cmd and cmd2. It also describes the tricks cmd2 uses for some of its more interesting functionality so that they can implement them in their own programs (even unrelated ones). It ends with a brief demonstration of sqlpython, a cmd2-based application that improves on existing ad-hoc SQL applications.

There is a fair amount of unnecessary animosity between developers about version control systems, especially between Mercurial and Git users. In reality, these two systems are very similar and can actually cooperate pretty well. In this talk we will show just how similar Git and Mercurial are, look at some of their technical differences, and see how they can work together by looking at hg-git, the bidirectional Git/Mercurial bridge, implemented in Python.

Drawing on experiences writing http://m.ox.ac.uk/, we'll explore the art of getting data out of unhelpful systems. We'll start with working out how to interact with a system, move on to techniques for parsing the data it gives you, and round off by implementing a shinier interface over the top.

The Echo Nest Remix API (http://code.google.com/p/echo-nest-remix/) was made open source by The Echo Nest, a "music intelligence" company based in the Boston area in the autumn of 2008. This talk will offer details on the concise expressivity offered when editing multimedia driven by content-based features, and some insights on what Pythonic magic did and didn't work in the development of the modules. Audio and video examples of the fun-yet-odd outputs that are possible will be shown.

This talk will show how Python and libraries such as NumPy were
instrumental at AQR for building a robust research platform for
prototyping and implementing quantitative trading models. We will
discuss many different tools, including pandas, a new open source
library designed for analyzing common financial and economic data
sets.
 
A variety of examples will be presented to explore Python's
current status as a replacement for other statistical computing
environments (as compared with R, MATLAB, or other commercial and
open-source statistical products).

The primary activity of the Dartslab (http://dartslab.jpl.nasa.gov) at Jet Propulsion Laboratory (JPL) is to create simulations of robotic vehicles for planetary exploration. We have created simulations of a wide variety of robotic vehicles such as spacecraft, rovers, and airships. We have been using Python in a variety of ways to build our simulations. In this talk we will outline how we use Python to set up a runtime environment for our simulations and to tie together computationally intense C++ code modules at runtime. We will also discuss how we have been using Python to help prototype and design C++ code.

There are an increasing number of continuous integration (CI) systems
available for use by Pythonistas, but no clear guide to how to choose
a CI system for your project. I will examine the architecture choices
made by buildbot, bitten, Hudson, continuum, CruiseControl, DART, and
pony-build, and discuss the configuration and customization of several
of these systems for Pythonic needs, as well as give short demos (for
buildbot, bitten, Hudson, and pony-build).

Since the dawn of concurrency research, there have been two camps: shared everything, and shared nothing. Most modern applications use threads for concurrency, a shared everything architecture.
 
Actors, however, use a shared nothing architecture where lightweight processes communicate with each other using message passing. Actors can change their state, create a new Actor, send a message to any Actor it has the Address of, and wait for a specific kind of message to arrive in it's mailbox.
 
We will discuss the benefits of using the Actor architecture and strategies for implementing an Actor system in Python.
 
http://bitbucket.org/fzzzy/python-actors/

Seattle [1] is an open-source platform for developing and deploying networked
applications. Core feature of Seattle is that it allows safe execution of untrusted code
on end-user systems. In our talk we look at how we used Python to build a safe,
restricted code execution environment for Seattle that not only provides
execution safety but also enforces strict resource consumption limits. In addition,
Seattle includes a high-level API to hide inconsistent OS-specific behaviors
from developers. What results is a platform that welcomes the participation of
end-user machines for general-purpose distributed programming and creates new
possibilities for developers.
 
[1] http://seattle.cs.washington.edu/

We will first define what blocking, non-blocking, synchronous and
asynchronous I/O are under the POSIX interfaces. We'll cover how and
when these four types of I/O should be used, and their individual
effects on a Python based application. The notion of concurrency will
be discussed by comparing a simple threaded blocking I/O application
to a simple single threaded non-blocking I/O application by walking
the attendees through the python code for those applications.

Python's flexible object model allows library and framework authors to add very flexible declarations. Metaclasses, decorators, callable objects, and operator overloading practically allow libraries to re-define the language in order to provide a more concise, natural style for that library. Unfortunately, the library user's first experience of such conveniences is often confusing, because it's not clear what's going on.
 
In this talk, I will try to convince you that all of this wonderful magic isn't all that weird. This is not a typical how-to session on how to use a particular feature, either of Python or of Twisted, but will rather draw examples from Python, Twisted, and Zope to illustrate techniques you can use to read and understand "magical" Python code.

This will be an overview of the sorts of things that editors can offer
to make your programming life easier. It will also include specifics of how to
get these features working in a basic editor. (Vim or Emacs, yet undecided)

In this talk, we will give an overview of VisTrails (http://www.vistrails.org), a python-based open-source scientific workflow that transparently captures provenance (i.e., lineage) of both data products and the processes used to derive these products. We will show how VisTrails can be used to streamline data exploration and visualization. Using real examples, we will demonstrate key features of the system, including the ability to visually create information processing pipelines that combine multiple tools and Iibraries such as VTK, pylab, and matplotlib. We will also show how VisTrails leverages provenance information not only to support result reproducibility, but also to simplify the creation and refinement of pipelines.

PubSubHubbub is an open protocol that turns Atom and RSS feeds into real-time streams. I built the reference Hub run by Google using Python and App Engine. In this talk you will learn how I made the real-time system work: An intro to the protocol, asynchronous processing on App Engine, fault-tolerance, and scalability.
 
For details on PubSubHubbub and the Hub's source code, see:
http://code.google.com/p/pubsubhubbub/

BFG is a Python web application framework based on WSGI. It is a "pay only for what you eat" framework. Meaning that you can get started easily and learn new concepts as you go, and only if you need them. It's simple, well tested, well documented, and fast. It also tries to make development fun.
 
This talk will introduce the framework and its philosophy, including similarities and differences with other frameworks. I will then show some of the software available in its repository and discuss the inclusive, loose connection approach that the BFG community prefers for creating a flexible web development platform.

Learn about Tortuga, the python powered Autonomous Underwater Vehicle (AUV) developed by Robotics @ Maryland (http://ram.umd.edu). See how python provides a flexible and efficient way to build the software that commands, simulates and controls Tortuga. Also learn about the trials, tribulations, and glory experienced developing, competing, losing, and winning with Tortuga in AUVSI AUV Competition (http://www.auvsi.org/competitions/water.cfm).

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.

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.

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.

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.

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.

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.

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.

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?

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.

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

Come hear about the trials and tribulations of moving reddit's Python application from physical hardware to EC2's cloud infrastructure, and how they have scaled since moving. Will include general discussion of their learnings about scaling as well cloud specific issues.