Talks

#0 Clever uses for metaclasses

Presenter: Matthew Wilson
Audience: advanced
Summary:

This talk introduces metaclasses and attempts to "defang" them, showing what they are good for, and when they are silly.

Metaclasses can reduce redundancy in code but can be very confusing, so in this talk, I will walk through several examples of how to use metaclasses to solve problems.

I plan to cover (at least) these examples:

* Add extra methods and attributes to a class after its definition.

* Verify a class correctly implements a specification.

* Give a subclass its own class-variables rather than sharing them with the parent class.

* Implement the basics of an object-relational mapper (ORM).

I published an article in the November 2009 issue of Python Magazine with the same title (Clever Uses for Metaclasses) and I'll use some code from that article.

I want to give this talk in a friendly, informal manner, so that people that feel intimidated by metaclasses realize that there's nothing to be scared of.

#1 Django: After the Tutorial

Presenter: Joe Tyson
Audience: beginner/intermediate
Summary:

Intended Audience

This talk is intended for programmers new to Python but not total beginners. We assume the programmer is able to set up VCS, databases, and webservers as needed and is comfortable with these tools. It is helpful, but not necessary, to be familiar with very basic Django concepts (covered in the Tutorial) and the basic install flow for Python packages. The latter half of the presentation is valid for any Python project.

Abstract

There's a gap between the Django Tutorial and the various documents about development and deployment. This talk will discuss the general pattern we use for Django projects, using the Tutorial code as a vehicle for demonstration.

We'll discuss codebase organization (where to put templates, "media" files, application code), settings management (how to handle different deployment environments without going crazy), and package creation. We'll talk about how to use key setuptools directives to fully control the (Python) dependencies in different deployment roles (including a very simple private "package server"). In the course of the discussion, we'll briefly cover virtualenv and virtualenvwrapper. Time permitting, we'll give a short introduction to Sphinx and talk about where the documentation files go in our package hierarchy.

#3 Python for Java Developers

Presenter: Eric Floehr
Audience: beginner
Summary:

This talk will outline some of the differences between Python and Java, and take some Java issues and how they are solved in Python, and also to be fair, some of the issues Java programmers might have when moving to Python. Some topics will include:

1. Interactivity and how BeanShell and others are a poor substitute

2. Named parameters and default values to functions
3. Tuples and dictionaries as first-class objects
4. Everything is an object versus Java, not so much
5. Mix-ins and multiple inheritance
6. Python modules versus Java classes and packages
7. Function pointers and the Java anonomous callback class hack
8. Dynamic dispatch
9. Unit testing
10. Where Python's dynamicism can trip you up

#4 Python for Fun and Profit

Presenter: Eric Floehr
Audience: unknown
Summary:

This talk will outline how I used Python to answer an interesting question and turned that into a successful business. This talk will be half-technical, half-motivational. The technical pieces will talk about Threading, Django, scaling, rapid development, etc. The motivational pieces will be that anyone can be an entrepreneur if I can...how to take something you love or a topic you are interested in, and show a real-world story of how you can turn that into a business.

#6 Inter-Process/Task Communication With Message Queues

Presenter: William McVey
Audience: intermediate
Summary:

This talk will introduce the concept of Message Queues, along with some libraries for using a message queue in your own project. The talk will cover at least:

• Standard lib Queue.Queue.
• multiprocessing.Queue
• beanstalkd and the python library beanstalkc for interacting with it

It may also include:

• using python to talk to an AMQP/RabbitMQ server and/or ZeroMQ
• using msgbus to show a comet based web app.

#7 Introduction to developing web application using Python

Presenter: Lotfi Ben Othmane
Audience: beginner
Summary:

We will talk about how to develop a simple web application using Python. The talk covers an introduction to architecture of web applications, hosting Python CGI pages, and developing CGI pages using Python. The talk covers developing simple CGI page, and developing CGI forms using Python.

Web site: http://www.cs.wmich.edu/~lbenothm/Teaching/Spring2009/CS2100/Slides.html

#8 Artificial Intelligence and Python: Developing a Conversational Interface Using Python

Presenter: Jerry Felix
Audience: unknown
Summary:

Conversational Interfaces (CIs) are programs that permit humans to interact with computers using natural language. As the state of the technology evolves from today's simple chat-bots to tomorrow's true strong Artificial Intelligence beings, Python sits as key component at the heart of these developments. Python has unique advantages as the development language of choice for Conversational Interfaces. In this presentation, I will introduce this exciting and rapidly developing field, explain Python's unique positioning and capability in this area, and demonstrate how users can easily use Python to create their own CI.

#12 Getting Started With Django

Presenter: Alex Gaynor
Audience: beginner/intermediate
Summary:

Django is one of the most popular web frameworks, and web development is a fascinating field to work in. This talk will be an introduction to development with Django, specifically for individuals who are new to Python. This talk will go through the steps of building a simple website, and showing some of the features Django has, such as its ORM, its template language, and its URL and view syntax. This talk will also touch on some pieces of Django philosophy, insofar as it pertains to learning Django, as the primary goal of this talk will be to get new users to the point where they can begin developing with Django themselves.

No prior knowledge of Django is required.

#13 Coroutine Use In A Cavern Simulator

Presenter: Jay Shaffstall
Audience: unknown
Summary:

Abstract: A discussion of the design decisions that went into using coroutines for a cavern development simulator, and what worked and didn't work with Stackless versus generators. Targets people who don't know what coroutines are, or haven't used them before. Also covers efficiency aspects of a large scale simulation written in Python.

#14 There's nothing wrong with buildbot that a complete rewrite couldn't fix

Presenter: Titus Brown
Audience: intermediate
Summary:

At Michigan State University, we are starting or participating in an ambitious set of projects to help integrate open source, Python, and software engineering into undergraduate CSE education. These projects, soon to be open for community use and participation, include:

• Snakebite, a distributed heterogenous build farm for Python developers.
• pony-build, a buildbot replacement build around Snakebite's requirements.
• the Python Buildhaus, a project to systematically build, test and release Open Source Python packages on Windows, Mac OS X, and a wide array of other UNIX architectures and operating systems (see snakebite.org for list). In addition to providing machine access, software support, and process support, we hope to create a set of best practices and process documentation to help the community address cross-platform compatibility issues. We will also build tools to extend the impact of this effort beyond Michigan State by providing longer-lasting developer resources, e.g. tools to auto-build Python eggs and installers across multiple platforms.

I'll talk about our progress in bringing Snakebite and the rest to fruition, along with technical decisions and discussion about the community impact of these projects.

#16 A Survey of Unit Testing Frameworks

Presenter: John Szakmeister & Tim Woods
Audience: beginner
Summary:

One of the great strengths of Python is the ability to reach the far annexes of your code, and wrap unit tests around them. Over the years, the number of Python packages has grown tremendously, making it increasingly harder to know what is available to a developer. This talk aims to close that gap, at least in the unit testing realm, by introducing several unit testing frameworks.

#17 Python not harmful to CS majors (and good for everyone)

Presenter: Bill Punch
Audience: unknown
Summary:

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.

#18 Game Development With Python and Pyglet

Presenter: Steve Johnson
Audience: beginner/intermediate
Summary:

Lots of people learn to program because they want to write video games. Python is a great language to write games in. As such, I would like to give a talk about how to go about writing games in Python. I will focus on the Pyglet library because of its ease of use and independence from other libraries.

I will cover:

• Why Python is a good language for 2D game development, and why the Pyglet library is the best way to write games in Python
• Writing a basic Pyglet app (drawing simple graphics)
• Loading things
• Using sprites, rendering in batches
• Input from mouse/keyboard
• Keeping track of time (time-based animation, scheduling functions)
• Displaying text
• Sound
• Contests! What's available?

  • PyWeek

  • uDevGames
  • Other stuff
• Other libraries of interest

  • PyGame

  • Cocos2D
  • Panda3D
  • Chipmunk Physics
  • YAML

My presentation will include demonstrations with sample code available online, as well as an invitation to an Open Space later in the day for more in-depth discussion if one is available. There are a lot of Python game developers and educators out there who have useful knowledge to share.

This presentation could easily be structured as a hands-on tutorial if people would prefer it that way. I was thinking I would run through the features and give a few demos during the talk itself, then do any hands-on work at the Open Space, but I would be happy to change the format if asked.

#19 Dependency Injection in Python w/ snake-guice

Presenter: David Stanek
Audience: intermediate/advanced
Summary:

Dependency injection is often thought of as a way for to overcome the static nature of Java. This is not true. It can used in Python to create highly decoupled, cohesive and configurable systems. I'll describe the what and why of DI.

• Define dependency injection
  • By hand
  • With a framework
• Why it's useful and explain with code examples
• Why DI makes for good OOP
• The SOLID principles

My DI framework snake-guice is based off of the successful Google Guice project. I'll be covering:

• Code as configuration
• Initializer injection
• Method injection
• Scopes
• Annotations
• Injection from configuration files
• Using snake-guice with Django/Pylons/CherryPy (i haven't decided which one)

#20 Extending Plone using the Zope Component Architecture

Presenter: Calvin Hendryx-Parker
Audience: unknown
Summary:

You've installed Plone from the installer and are already managing content like a pro. Now you want to extend the capabilities while at the same time making sure keep your upgrade path to newer versions of Plone clear. Plone has the ability to be extended using the powerful Zope 3 Component Architecture (ZCA). Using p4a.subtyper and the archetypes.schemaextender packages, you can now easily extend the built in content types with enhanced functionality. This presentation will cover using the ZCA's Interfaces, Adapters, Views, and Events to build sustainable Plone customizations.

#21 Using Buildout to Develop and Deploy Python Projects

Presenter: Clayton Parker
Audience: beginner
Summary:

Buildout gives you a way to manage, build and deploy your Python project with ease. Large Python projects such as Plone use it to distribute repeatable development environments. Buildout allows you to easily get up and running with your project versus the traditional method of installing all the dependancies and manually configuring your applications instance for each environment. The buildout community is rapidly growing with a large repository of recipes that allow you to extend its functionality. This talk will show you the basics of using buildout and how to make it a vital part of your project's life cycle.

#22 Operator Overloading and More

Presenter: Neil Ludban
Audience: beginner
Summary:

Operator overloading in Python is as easy as adding methods to your class with special "double underscore" names. But it doesn't stop with simple arithmetic operators in a dynamic language like Python. The interpreter, builtin types, functions, and modules support a number of design patterns which make the language easier to learn, apply, and extend. In this presentation we'll cover the special methods used for operator overloading, object attribute and item access, and type coercion; then survey PEP 3119 (Abstract Base Classes) terminology and protocols between the interpreter and objects; and end with a review of the builtin types emphasizing new terminology. The presentation will be an introduction suitable for beginner and intermediate programmers.

#23 Deciding on a Python Web Technology Stack

Presenter: Mark Ramm-Christensen
Audience: beginner
Summary:

SourceForge recently rewrote all of their download pages using a modern web stack, including Python, TurboGears 2, and MongoDB. This talk discusses our approach to the problem, and the suite of tools that we used.

Non-relational database technologies are becoming more and more popular. And we were having trouble scaling the current SourceForge platform on top of a traditional RDBMS+php stack. This talk will discuss our exploration of Redis, Scalraris, Tokyo Cabinet, Couch DB, MongoDB, and many others, as well as the process that we used to decided between Django and TurboGears in this and other Projects.

Canceled Talks

#10 Pumping Iron into Python: Intro to FePy

Presenter: Sarah Dutkiewicz
Audience: beginner
Summary:

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.

#11 Show & Tell: IronPython Edition

Presenter: Sarah Dutkiewicz
Audience: beginner
Summary:

In this session, you will hear about IronPython and what is needed to work with this .NET implementation of the python language. This session will show the power of IronPython in a Windows environment. There will be many demos of how IronPython can be used - including some WPF, XNA, Silverlight, COM Interop, database interaction, and other neat features.

#24 Extending and Embedding Overview

Presenter: Nicholas Bastin
Audience: intermediate/advanced
Summary:

An overview of extending and embedding the Python language for your own applications, highlighting the benefits and challenges inherent in building your own extension modules. Coverage of capabilities, 3rd party toolkits (SWIG, Boost.Python, Cython, Pyrex, etc.) and notable examples of both extending and embedding.

#25 Using Amazon Web Services

Presenter: Nicholas Bastin
Audience: beginner/intermediate
Summary:

Overview of Amazon Web Services and packages for interacting with them from your Python applications, with examples, applications, and patterns. Discussion of the history of AWS, competitors, and general advantages and disadvantages of the cloud model.

#26 developing a commercial application with python

Presenter: Kevin Dahlhausen
Audience: beginner
Summary:

I'd like to propose a talk on developing a commercial application with python. Earlier this year I released ErgMate, a commercial desktop application written in wxPython. My talk will cover motivation, build system, freezing, and key protection of the application.