Many advocates of unit testing believe that testing desktop (GUI) applications is so difficult as to not be worth it. Not only is it possible, but 'functional testing' (testing an application from the point of view of the user) is an important part of an agile development process.
 
This talk is based on my experience of testing a spreadsheet application with Resolver Systems. Whether you have drunk the agile kool-aid or not, functional testing can improve your application and your development processes.
 
The basic topics covered are:
 
* Why test functionally (including some unexpected benefits)
* The processes and infrastructure around automated tests
* How to functionally test - general principles and specific examples
* Difficulties and fragilities - and how to minimize them
 
 
Online Slides:
 
http://www.voidspace.org.uk/python/articles/testing/index.shtml

How python saved the day of a small group of developers having to write a complex media center software for a mobile system in less than 4 months.
 
Talk covers use of Python in embedded systems, the Nokia/Maemo platform, using bindings of the Enlightenment Foundation Libraries (EFL) to run fancy and fast graphical "iPhone-like" user applications on that platform, proving that it is a viable platform for such low end systems. Final software (http://openbossa.indt.org/canola2) was delivered on time with excellent user experience, a real iPod Touch contender!

This session will discuss how you -- yes, *you* -- can give talks about Python at your local user group and at events such as PyCon. The talk will discuss how to decide upon a topic, how to prepare the presentation, and suggest various tips for improving your delivery.

This talk will cover the new multiprocessing package included with Python 2.6 (and 3.0) focusing on design, benefits, practical usage, application construction, gotchas and how to use it to build multi-core and distributed applications.

The benefits of continuous test integration are well known. Setting up an infrastruture for this can be a lot of work. It involves integration with version control, automated product building and running of tests, reporting on results in an accessible way, code coverage measuring, and code analysis such as with lint-like tools. We discuss how to set up such an automatic QA system using extensible open source python tools. The focus will be on Buildbot (http://buildbot.net), an open-source, Python-based continuous integration framework. Topics include a survey of the current best available open source software; testing code in languages other than python (and the benefits of using tools written in python in such a situation); strategies for extending these tools to meet custom needs, while avoiding maintainability and quality pitfalls; and special bonus details for QA of projects implemented in python specifically.

Crunchy (http://code.google.com/p/crunchy) is a program that transforms a static Python tutorial into an interactive session within a browser. In this talk, I will present Crunchy, focusing on the features that are specifically designed to be helpful in a formal teaching setting.

Traditionally Python has worked one of two ways: either a program with an edit-run cycle or a command prompt where the user types commands. Reinteract introduces a new way of working where the user creates a worksheet that interleaves Python code with the results of that code. Previously entered code can be changed and corrected. The ability to insert graphs and plots in the worksheet makes Reinteract very suitable for data analysis, but it also is a good for basic experimentation with the Python language. This talk introduces Reinteract and gives a high-level peek at the magic behind the scenes.
 
http://www.reinteract.org/

As Python grows in popularity, IronPython has started making more waves. What is IronPython and why should regular Python programmers be familiar with it? This session will introduce the open source .NET implementation of Python known as IronPython without using Windows. Come see FePy (IronPython community edition) in action via Mono -- a cross-platform open source implementation of the .NET framework.

Paver makes managing common aspects of Python projects easier, by providing just the right kind of scaffolding on which to automate building and packaging of your software. In this talk, you'll see how easy it is to get started with Paver, how you can use Paver without alienating other users of your code, and how you can use Paver to trivially extend Python's distutils commands.

At Michigan State Computer Science Dept. we have recently converted our CS1 course (200 students/semester, about 60% non-CS majors) to Python, previously taught in C++. Follow on courses for CS majors (CS2, etc.) still use and teach C/C++. Right around the conversion point, we had two groups of students taking the C++ CS2 course: those that took CS1 in Python and those that took CS1 in C++. We examined the performance of those two groups of students in the CS2-C++ course (covering the same topics as previously), looking for any significant differences as measured by t-test with respect to: final exam grade, overall programming project scores and final course grade. No significant differences between CS1-Python and CS1-C++ were found. Further, multiple regression analysis showed that only GPA was a good predictor of the three outcomes. Neither CS-1 Python nor CS1-C++ was a predictor. Our conclusion is that a CS1-Python course was as good a preparation for a CS2-C++ course as was a CS1-C++ course. Furthermore, CS1-Python was a far better terminal course for non-majors than CS1-C++, and both majors and non-majors were could address a wider range of practical STEM problem than previously. We have written a CS1-Python book for others who wish to teach a Python-CS1 course that emphasizes teaching Python to CS1 students with a theme of data manipulation.

This panel will bring together all four major implementations of Python (CPython, IronPython, Jython, and PyPy) in one room to answer questions from the public for the first time. This Q&A session will provide people a chance to get questions answered from key members of the various Python VM teams.
 
There is a Google Moderator track created for attendees to add and vote on questions:
http://moderator.appspot.com/#15/e=2fa6a&t=31181

Alternative databases to the traditional relational database model are becoming more prevalent, with Google DataStore, Amazon SimpleDB, CouchDB, eXist XML database, and other databases getting more traction and enticing more developers to consider them. This talk focuses on evaluating when a website's needs might be better suited by one of these alternatives and what their strengths and weaknesses are. Examples are presented using the Pylons framework along with implementations building on the unique strengths of a non-relational database with various content storage considerations.

The authors of the Data Acquisition System used for the IceCube Neutrino Detector at the South Pole describe the critical role Python plays in the software ecology of IceCube, and touch on tangential issues of working in a large, international collaboration, as well as life and work at the South Pole.

This talk will describe how zc.buildout is used in our company every day to develop, package and distribute Pylons, Django or Plone applications. It will focus on the best practices we have built around the tool and the tools we have built on the top of it to speed up our work.

Imagine being able to create a rich web application using nothing but Python. No HTML, Javascript - just pure Python. Now you can with the Dabo framework. You can now create web applications as well as traditional desktop applications using Dabo. This session will cover the basics of developing both web and desktop applications using Dabo.

Compare and contrast the philosophies of the different ORMs. Also look at the technical implementation, design decisions, and difficulties.

Coverage testing measures the execution of code, and is a great way of testing your tests: are they exercising all of your code? There are some pitfalls to be aware of in implementing coverage testing, though. 100% coverage is a fabulous ideal, but not only is it hard to reach, it still leaves a lot to be desired.

Pinax is an open-source platform built on the Django Web Framework that dramatically reduces the time it takes to develop Web sites. By providing a wealth of social and collaborative features out of the box, Pinax rapidly increases the speed at which your websites can be developed and launched. This talk will provide an overview of Pinax and how you can use it as the foundation for your sites.

Think Python is too resource-intensive for low-power 8-bit embedded systems? Think again! Developed for low-cost wireless (802.15.4) modules, the SNAPpy virtual machine enables users to modify embedded device behavior dynamically over the air, leveraging the power of Python. In this session a key architect of the technology will discuss software, the virtual machine approach, and real-world success stories. This presentation features live demonstrations of the SNAPpy virtual machine running on readily available battery-operated wireless sensor nodes (RF Engines) from Synapse. You'll also see first-hand the power of Portal - a wireless application development GUI developed using wxPython.

Windmill is the best-integrated solution for Web test development and its flexibility is largely due to its development in Python. This talk will get you writing and running automated tests and show off some of the most useful built-in tools for debugging and continuous integration.

PyPI has become an important piece of the puzzle when it comes to build and deliver some Python applications : you can declare dependencies in your package to third-party libraries, and tools like setuptools or zc.buildout will try to get them at PyPI.
 
This brought up two new problems:
 
- what if PyPI is down ?
- what if the package is private to your company, and you don't want it at PyPI ?
   
This talk will present:
 
- the current status, and how people work with PyPI
 
- the work done lately in catalog-SIG to set up a mirrors ring,
  and the different solutions used to run your own package index
  or your private or public mirrors.
 
It will also discuss how client applications like setuptools could use fail-over and
index-merging mechanisms;
 
See http://wiki.python.org/moin/PEP_374 for the ongoing work.

In building our new online database at Fluidinfo, we needed scalable and reliable messaging/RPC for a system of heterogeneous services. We chose two proven open-source components, AMQP and Thrift, and adapted these to work with Twisted asynchronous networking.
 
The result - also open source - is a simple, general, and flexible system for connecting the components of a complex distributed application. With a message broker at its core, it provides for scaling, replication, load balancing, and distributed transactions. It also transparently handles returning exceptions and Twisted Deferreds from remote services.
 
I'll describe architecture, example code, benchmarks, advantages, and alternate approaches.

As we become more efficient at producing web sites, inevitably the issue of quality (or lack thereof) can begin to slow the velocity at which implementation teams are able to move forward. Functional testing tools can help increase quality, bolster team confidence and keep things running smoothly.
 
This panel will bring together the maintainers of several functional testing frameworks written in Python. The session will be split into three distinct parts:
 
1. A lightning talk style introduction to each framework.
2. A guided discussion around the application of each framework.
3. A question and answer session with the audience.

By using plugins, one can create software that is easily extensible by others, thereby promoting collaborative development. The flip side of extensible software occurs when dealing with some standard framework whose interface is closed but which does not do exactly what is desired. In this case, monkeypatching may be worth considering.
 
In this talk, I'll give concrete examples of both plugin design and using monkeypatching, using small code samples from existing projects, and discuss the advantages and the shortcomings of the methods used. I will also include the design of a tiny, but flexible module for generating svg code - and compare it with other existing approaches.

The TurboGears web framework has stable and supported 1.x and 2.x versions. This talk will cover what's new in these new versions, and what's coming to TurboGears in '09. I'll also be talking about what web framework development means in a world of reusable WSGI components, and how the python web world has radically remapped itself over the 2 and a half years since TurboGears was released.

An explanation of some of the underlying concepts of Python, come learn about names and values placed in namespaces, modified by code objects and collected into modules. We'll explore namespaces using the Python interactive prompt, with graphical display of object trees using Graphviz. Also explained will be the namespace concepts of closures and early binding; how to define new objects without subclassing via use of default/curried arguments and closures.

Fedora's Infrastructure team utilizes multiple python technologies and has deployed 6 home built TurboGears applications in the last year and a half. It's not just a development platform, it's also a way of life in the Infrastructure team. Lots of custom scripts and systems administration via func only scratch the surface of what Fedora is doing with Python.

This talk will cover the recent changes to Python 2.6, including a brief introduction to the threading module and multiprocessing inclusion and changes but will primarily focus on the concurrent and distributed ecosystem for Python today.

"Scripting" with Python is becoming more common. This talk will discuss why you would want to "script" with Python (instead of say bash). It will also discuss best practices that will allow you to actually test your scripts, maintain them over time, and easily distribute them. Python has some advantages to bash in these areas.

It all started in 2003 with Plone, continued in 2005 with Zope3 and right now the road seems to go to the Cloud, namely Google App Engine.
 
In this talk the experiences building a community portal based on Google App Engine will be presented. The main parts are: the App Engine Python SDK, Google's Bigtable, the Admin AJAX interface based on Google Web Toolkit / ext GWT, the delivery frontend using Django, Amazon Webservices handling large files and Content Delivery and of course as mentioned beforehand business aspects.

As a Python web developer you are probably familiar with the paradigms of testing simple web applications. Your test case makes a GET / POST request, your program responds with an HTML page, and your test verifies the HTML elements. Unfortunately, today's typical web application is not so simple! Since modern browsers support asynchronous JavaScript (Ajax) very well, the HTML response might deliver program code to run on the client's web browser. The browser's runtime environment would then interact with your server-side Python program and you now have a big problem: How does your test suite cover both server-side functionality and client-side functionality?
 
This talk will use a real Python / Ajax web application as an example then offer practical strategies for creating a fast, scalable test suite to help ensure that each release of such an app works as intended. It goes beyond just the tools and technologies; it examines architectural strategies -- how and when to use stubs, how to design a testable UI, etc -- so that as your application grows in size, your tests remain fast and effective.

There is a distinct lack of Design Patterns discussed in relation to Python. Are the communities ignorant of Design Patterns or is there something else going on here? This talk is based on my well-trafficked article "Python isn’t just Java without the compile" and expands on that article by using Design Patterns as a crude metric of gaps in a programming language.

In this talk I will discuss some of the most interesting advances that have occurred in the 2.5 release of Jython, and some of the cool stuff that is being developed for 2.7 and 3.0. I will pay particular attention to Python frameworks and apps that are now working in Jython. I will also talk about some of the Java integration features that will be in Jython 2.5 (and beyond). I will demo some of the cool things that you can do with Python and Java together.

OpenGL 3.0 has deprecated the traditional “fixed” OpenGL 1.0 pipeline. Almost every PyOpenGL script has been built using the OpenGL 1.0 fixed pipeline. When OpenGL 3.1 arrives, those scripts will break on operating systems that solely support 3.1, particularly the newest and best hardware. This talk will describe how to transform your PyOpenGL code to be “future proof” and to take advantage of the programmable OpenGL pipeline and related features.

Python's implementation is slow, but you can often write fast Python if you know how to profile your code effectively. This presentation will show you how to use the built-in cProfile module to capture profile data, both in simple scripts and more complex GUI environments. We'll look at how to interpret the profile/cProfile reports as well as a few external tools to make the reports easier to understand. We'll discuss how to make profiling an effective tool for you and some common "hot spots" you'll discover in Python code.

Web applications provide many advantages over traditional desktop apps, but there are still times when users need to run an application without a network connection. A Browser Interface, Local Server (BILS) application provides a way to present your users with exactly the same interface as the web app, using a single code base, while the app runs on entirely on the local machine. We will discuss a number of options available for and shortcomings of developing a BILS app, and present the example of NOAA's CameoChemicals, a Pylons-based web app wrapped in a wxPython interface for desktop use.

Everyone's heard of C extensions to Python, but few have ventured into those murky depths. This is a quick overview of how to write a C extension, complete with highlights of the C API, memory management, error handling, and type creation. Whether you want to speed up your Python, integrate with legacy code, contribute to Python's core, or just learn a little about how it all works under the covers, you will enjoy this trip through unfamiliar territory. I guarantee you will return safely.

When faced with the simple task of figuring out how to use configuration to your advantage in Python there are a myriad of methods. The purpose of this talk is to walk through the standard library modules and the popular Python Package Index modules comparing and contrasting configuration formats and the code that consumes them. Specifically, I would like to walk through the use of the csv module, the ConfigParser module, ConfigObj, lxml, PyYaml and SimpleJSON.

PyPy has come a long way. It's gone from being purely a research project to providing a flexible and reasonably fast Python Interpreter, itself implemented in Python. Although PyPy is not yet a viable CPython replacement, PyPy is able to run sophisticated python applications like Django and Twisted. In this talk, we'll focus on improvements that happened during the last year in PyPy. This talk will also explain the motivations driving current PyPy developement and its targets for the future.

This talks takes a look at the various options of migrating to Python 3, and takes up examples of some tricks you can do to make you code run unmodified under both 2.6 and 3.0.

Over the past eight years CCP have been developing computer games like EVE Online (www.eve-online.com) using Python. In this presentation we'll show the Python-based tools we've created and techniques we've employed to aid us in this process. Our framework customises the development experience which our programmers engage in, from our own custom namespacing approach, to code reloading, unit testing, systems testing and Python-based GUIs. We'll endeavour to demonstrate each of these and where possible elaborate on what is involved in implementing similar systems.

Django is a high-level web development framework designed for rapid development of database-backed web sites. Since its release three years ago Django's grown by leaps and bounds; it's now part of a highly successful new generation of web development tools.
 
However, it hasn't all been smooth sailing for the Django team. As any Open Source community does, we've needed to make a series of tough decisions along the way. These decisions have shaped Django's internals, public APIs, and community.

Django 1.0 was released in September 2008. This release marks a major turning point in Django's development; a real maturation of the project. Join the lead developers of Django as they discuss what's new in Django 1.0, cover the Django 1.1 release (currently scheduled for a few weeks before PyCon), and discuss the project's future.
 

Finite state machines are a simple yet very powerful mechanism for modeling behavior of different program entities during their lifetime in response to events.
 
The first part of the talk introduces the finite state machine concepts illustrated using the formalism described in the UML specification. Picking up these concepts is easy and no prior knowledge of UML or state machines is needed. The talk also focuses on the best practices of using state machines.
 
The second part of the talk gives an overview of the Statemachine library (http://www.reason.bg/statemachine/). It provides answers to how was the library implemented and how to use it.

If you've ever created a nifty application that makes people's lives easier you know the truly hard part is convincing others to use it. One way to increase the number of people installing your software is to convince Linux distributions to package your software so that their end users can install by using the system tools they're used to. One way of convincing them is by making your application easy to package.
 
This presentation shows you one way to use Paver (http://www.blueskyonmars.com/projects/paver/) to do just that. It gives you a recipe to make installing your application in the appropriate filesystem paths easily customized to the needs of the packager.

Building a flexible and scalable functional testing framework for your application is typically an evolutionary process. You experiment and find things that work, and things that don't, particularly if you have little programming experience. Sometimes, you proceed down a path that binds your hands later down the road, and a massive refactor is needed. I would like to present a simple testing framework built upon several existing, free technologies (ConfigObj, twill, nose) and models (Page Objects, Scenario Objects, Abstract State Machines) that is easy to configure, extend, and maintain.

At PyCon 2006 we gave a talk about how Stackless Python was being used to power EVE Online, a MMORPG developed and run by CCP Games in Iceland. Three years on, we report on how we redesigned the system's internals using a new IO framework called StacklessIO and how it helped solve network latency issues and improve the game's performance and scaling.

You get a call from your bank asking "Are you logging into your account right now?" With your answer you can either continue banking or stop an intruder from accessing your account, without the hassles of the Chase secret agent man. While a phone call to verify identity would be overkill for a forum post, you can add this to your website login process to verify identity and give your customers peace of mind.
 
We will look at multi factor authentication with user acceptance, how to extend some common Python web frameworks, and integrate the Asterisk VoIP platform. Sniffers, key loggers, or shoulder surfers are no longer a problem. You don't need a secret agent, just a bit of Python.

Computer programs fail. We do everything we can to prevent, trap, and handle errors before they cause trouble, but there comes a time in every program's life when its assumptions about the universe are suddenly not true and there is nothing left to do but "assert False".
 
In a high-reliability system we must be able to correct whatever the problem is and restart from the last-known-good state of our computation, as quickly as possible, without dropping any input data on the floor.
 
This talk presents one approach to precise state checkpointing and restart in a high-volume data analysis application. Our application, QuietCare (http://www.quietcaresystems.com), is a behavioral telehealth monitoring system currently deployed in thousands of senior citizens' homes and residential facilities in the US and UK. It is implemented in Python and SQL.
 
The approach will be of interest to any Python programmer wanting to maximize the reliability of a database-driven application.

At the last PyCon we announced that we were starting a project for improving the Jython compiler. This year we will share the first fruits of that work with the Python community!
 
This will be a fairly advanced talk about the prototype for an optimizing compiler for Jython. I will present the general structure of this compiler, the optimizations it performs and the performance improvements it gives.

For many of us, Python has dramatically changed our professional life: Open Source, technologies that get the job done, and let you learn and improve every day, a friendly and mature community, etc. Python is important! For learning, for science, for business, and for progress in general.
 
A group of people are working to promote Python and its ecosystem of tools, practices and projects, in new regions where it is not yet popular, in particular in South America and Africa.
 
This talk is a presentation of these efforts to help raise awareness on its importance and get more people participating.

Since releases 2.6/3.0 Python has a new turtle module. It was conceived primarily as a tool for teaching in a way that allows for using a range of different programming styles as well as different approaches to doing geometry, thus constricting the instructor's approach and ideas as little as possible. One of the main goals was to provide quick interactive access to nevertheless powerful graphics without any need of preliminary GUI-composing overhead.
 
The talk will show seven ways to use this module, using concise examples to illustrate them. Albeit short - these examples will cover a range from very simple to somewhat sophisticated, but most of them impressive.
 
Have a look at them and see if there's something you like or something you find useful.

How to run untrusted Python code? Old question, new answer! We'll showcase the PyPy virtualization approach which allows to control all IO, syscalls, CPU and RAM resources of a Python interpreter. We'll discuss the usage model, shortcomings and future possibilities.

CherryPy is an HTTP framework which is easy to use and extend. This talk will give an overview of CherryPy's features, with an emphasis on how it differs from "full-stack" frameworks (and why that's to your benefit).

Before Microsoft created LINQ, Python had Dejavu: a full-featured framework for querying wildly different data sources using normal Python syntax. This talk will give an overview of Dejavu, and show how easy it is to integrate and manage data in Python.

There has been a lot of buzz in the Python community about Python's new standard in Documentation systems. This talk starts with a discussion about the motivation for using sphinx. We then move on to a short screencast which demonstrates how to get started with sphinx, and how to utilize sphinx's autodoc features. I will then discuss shortly doctests, and how they can be used to both test and document your project. Next I demonstrate how nosetests, and sphinx can be integrated in your development process to produce well tested documentation, using another short screencast.

If you start your own company or run your own project you can usually choose the programming language, but if you work for a large company there are probably architects and others who keep a tight rein on approved technology. How do you steer a big ship towards dynamic programming languages, and how fast can it turn?
 
Come hear the story of one software developer employee who in 20 months facilitated the adoption of Python as the standard scripting language for an enterprise with 25,000 employees. Leave with ideas for advancing dynamic programming languages in your workplace, and with hope that change is possible.

IronPython is an implementation of Python running on .NET. This talk will provide an overview of the IronPython internals. The talk will start with a high-level walk through of the IronPython architecture and source layout. From there we’ll drill into details such as method dispatch, how the .NET and Python type systems interrelate, multi-runtime support, and how IronPython uses the DLR. Finally we’ll bring it all together and show you how you can do Python aware interop between .NET and IronPython. Whether you’re just curious about language implementations, planning on hosting IronPython in your own app, or just want to write a new built-in module for IronPython you’ll find something interesting in this talk. Knowledge of C# would be helpful but is not required.

Jython is back, and better than ever.
 
This talk covers how you can use the lightweight, flexible Pylons web framework to create web applications on Jython. I'll also cover some of the challenges encountered in the porting of Pylons and its dependencies to Jython.

Plone is a great content management system, recently voted best non-PHP open source CMS in a popular yearly contest. Many Python web developers, however, find Plone somewhat heavy and are not precisely in love with Zope, the web framework behind the CMS.
 
What if you could use Plone only as a CMS and program a frontend in whichever Python web framework you want, with transparent access to the content? This way you get a proven, high-reward, low-maintenance CMS as a content backend and are free to write your application on top of that using the power and flexibility of your favorite web framework.
 
In this talk, I will show how this can be done using a couple of Plone products and simple front ends for various frameworks which can be used as a base for other required functionality.

Django is the most popular Python web framework, and the final release of Jython 2.5 should be available a couple of months before PyCon. This means we can now use a modern Python web framework on top of Java infrastructure by running Django on Jython. In this talk, we will show examples of how to use this combination, engage a discussion about what can take the Python (and Django) community from the Java world, especially the necessary infrastructure bits, and how a Django/Jython stack compares with other JVM web stacks like JRuby on Rails.

The rise of utility computing platforms such as Amazon EC2 has made it more feasible to build turnkey hosted solutions on top of open source software. Learn how we built PondCMS, a turnkey CMS deployed to Amazon's EC2. This session will discuss the advantages of hosting Plone sites in the elastic computing cloud and some of the challenges we faced.

Class decorators have the similar utility as metaclasses but are simple enough to actually read and write.

Learn how reStructuredText, a powerful text markup language, can make documents rich containers of extractable data and drive your unit tests while still remaining very readable and convertable to HTML, LaTeX and PDF. Hear about Sphinx, the software used for docs.python.org that hierarchically organizes and cross-indexes multiple documents. Explore the implementation of new directives and text roles for supporting flash video embedded in your documents.

There are many deployment options for Python code. I'll share what has worked well for me on Windows, packaging command line tools and services using py2exe and InnoSetup. I'll demonstrate a simple build script which creates windows binaries and an InnoSetup installer in one step. In addition, I'll go over common errors which come up when using py2exe and hints on troubleshooting them. This is a short talk, so there will be a follow-up Open Space session to share experience and help each other solve distribution problems.

Abstraction is a powerful servant, but a dangerous master. We code, design, think, debug ... on a tower of abstractions. Spolsky's Law tells us that "All abstractions leak". This talk explores why they leak, why that's often a problem, what to do about it; moreover, I cover why sometimes abstractions SHOULD "leak", and thus how best to produce and consume abstraction layers.

Adrian Holovaty, bad-boy YouTube guitar star (search for him, if you dare!) and co-author of the Django web framework, takes you under the hood of EveryBlock.com, a Knight Foundation News Challenge startup which rounds up local news and information, and is powered 100% by Python and Django.

Covering large codebases with automated tests is a challenging and frustrating task that can be made much easier by approaching the problem systematically and choosing good tools. I will discuss a number of approaches and freely available tools that can help people "tame" pre-existing codebases with automated tests, and show the evolution of tests for a complex codebase under these approaches and tools.
 

We are moving firmly back into a "polyglot" world in terms of programming languages. This presents great opportunities for Python (and other dynamic languages) as well as challenges. In this talk I'll be discussing some of the challenges and opportunities that I see for Python, based on my experience with dynamic language runtimes at Sun.

Building large systems on top of a traditional single-master RDBMS data storage layer is no longer good enough. This talk explores the landscape of new technologies available today to augment your data layer to improve performance and reliability. Is your application a good fit for caches, bloom filters, bitmap indexes, column stores, distributed key/value stores, or document databases? Learn how they work (in theory and practice) and decide for yourself.

Survey several basic AI techniques implemented with short, open-source Python code recipes. Appropriate for educators and programmers who want to experiment with AI and apply the recipes to their own problem domains. For each technique, learn the basic operating principle, discuss an approach using Python, and review a worked out-example. We'll cover database mining using neural nets, automated categorization with a naive Bayesian classifier, solving popular puzzles with depth-first and breath-first searches, solving more complex puzzles with constraint propagation, and playing a popular game using a probing search strategy.

Python, like any other open source project, has its own way of doing things when it comes to development. To an outsider it can seem complicated and difficult to break into. But in fact, Python's development practices are simple as long as you know what the basic workflow is. This talk will go over that workflow, from how a bug ends up getting fixed to how a new language feature get added. In the end people should have an understanding of how Python is developed and how anyone can contribute to the project.

Come learn about our secret plans to use IronPython to take over the world. The emphasis will be on demos showing the seductive possibilities that IronPython enables for Python developers. These include taking advantage of the newest features in Windows 7, running your Python code in the browser with Silverlight, and many more.

Steve Holden, Chairman of the Python Software Foundation, reflects on the meaning of the phrase "the Python community" and the changes that have taken place in the PSF in the last year. He discusses further possible changes that could turn the PSF into a more "community-facing" organization, and solicits your input on what kind of projects and activities it should be supporting.

Ian Bicking, man of interest, discusses topics of interest. Interesting topics may include metaprogramming, whitespace, process models, past design mistakes, ambitious new directions for future design mistakes, a best dressed/worst dressed guide to Python libraries, open source community design patterns, and whatever else meets his exacting standards for Interestingness.

The goal of metaprogramming is to provide greater leverage by writing code that modifies other code. This presentation introduces metaprogramming and shows examples using both decorators and metaclasses. Although decorators are preferable because they are more straightforward, there are situations where metaclasses are still necessary; we'll look at these special cases and visit some initialization issues along the way.