Home Search Download Documentation
Help Community SIGs Modules
Email us
ipc6@python.org

  

Tutorial Program

There are four tutorial tracks. Each track has a morning and an afternoon session. Each session lasts about 3.5 hours with a 15 minute break in the middle. Exact break times are at the tutor's discretion.

Breaks and lunch are catered, and tutorial participants are invited to the reception in the evening. Unfortunately, our logistical set-up does not allow participants to have hands-on experience; however, copies of the presenters' annotated slides will be handed out, so you won't have to take notes. You can switch tracks between sessions.

Fees: Early registration for PSA and Usenix members is $200 for a full day of tutorials (one morning and one afternoon session). Add $50 if your payment is received after September 12, and if you are not a PSA or Usenix member at the time of the conference, add another $50 to join the PSA or renew your membership ($25 if you are a full time student).

Program Changes

There have been a few changes (for the better!) in the program since it was first published:

  • The COM tutorial will be taught jointly by Greg Stein and Mark Hammond.
  • The Python/C Integration tutorial (formerly Python/C API) will be taught by Mark Lutz instead of Guido van Rossum.


Schedule

8.00 am Registration opens (closes at 5.00 pm)
8.30 am breakfast
9.00 am Morming Sessions (see below); 15 minute break at tutor's discretion
12.30 pm lunch
2.00 pm Afternoon Sessions (see below); 15 minute break at tutor's discretion
5.30 pm free time
6.00 pm Reception for all conference participants
8.00 pm dinner (on your own)


Track 1: Introduction and COM

  • Morning session (9:00-12:30): Introduction to Python (abstract)
    Tutor: Paul Dubois, LLNL

  • Afternoon session (2:00-5:30): Python and COM (Microsoft's Component Object Model) (abstract)
    Tutors: Greg Stein, Microsoft; and Mark Hammond, Australia

    Track 2: Numeric and Scientific Computing using Python

  • Morning session (9:00-12:30): Numeric Python (abstract)
    Tutor: David Ascher, Brown University

  • Afternoon session (2:00-5:30): Scientific Computing with Python (abstract)
    Tutor: Konrad Hinsen, Institute for Structural Biology (CEA/CNRS), France

    Track 3: Extending and Embedding Python

  • Morning session (9:00-12:30): Python/C Integration (abstract)
    Tutor: Mark Lutz, Coral Systems

  • Afternoon session (2:00-5:30): Python-C/C++ Integration with SWIG (abstract)
    Tutor: David Beazley, University of Utah

    Track 4: Web server programming in Python

  • Morning session (9:00-12:30): Introduction to CGI programming in Python (abstract)
    Tutor: Aaron Watters, Lucent Technologies

  • Afternoon session (2:00-5:30): Beyond CGI (abstract)
    Tutor: Jim Fulton, Digital Creations


    Session Abstracts

    (More abstracts will be added as they become available.)

    Numeric Python

    Tutor: David Ascher, Brown University

    This tutorial will introduce the Numeric extension to Python, developed by Jim Hugunin with the support of the Matrix SIG. This extension provides a new high performance multidimensional array type and lots of related tools which allow the use of Python to do serious number crunching, while still keeping the `feel' of Python. This extension is currently in use in vision research, speech recognition, computational chemistry, physics, financial analysis, etc. The tutorial will provide an introduction to this new set of tools, common usage patterns and some of the more commonly used extension packages. While I will assume that the audience knows at least some Python, novices should be able to follow with no problems.

    Scientific Computing with Python

    Tutor: Konrad Hinsen, Institute for Structural Biology (CEA/CNRS), France

    This tutorial will show how Python can be used effectively for common operations in scientific computing, such as data processing and analysis, data management, visualization, algorithm prototyping, file format conversion, interfacing to and between legacy programs, etc. A basic knowledge of Python will be assumed, but general programming experience should be sufficient to follow the presentation. Participants with an interest in data processing and number crunching should also sign up for the tutorial on the numerics extension; the material presented there will not be repeated.

    Python-C/C++ Integration with SWIG

    Tutor: David M. Beazley, University of Utah

    This tutorial will show how Python and C/C++ can be easily and effectively combined using SWIG and other automated interface generation tools. Python and SWIG offer C/C++ programmers a powerful set of tools for building extensible applications, working with legacy codes, rapid prototyping, debugging, and developing cross platform applications. They also offer Python programmers a mechanism for implementing performance critical functions in C or C++. Currently, SWIG is being used in a wide variety of applications ranging from scientific, financial, graphics, databases, visualization, and CAD. The tutorial will cover the basics of using SWIG, advanced Python features, customization, interface building strategies, code design, portability issues, and limitations. Examples will be given for both Unix and Windows-NT. Participants should have a good grasp of C (or C++) programming, be reasonably familiar with C/C++ compilation tools (compilers, linkers, makefiles, etc...), and have a basic knowledge of Python. Participants may also want to sign up for the "Python/C integration" tutorial or the "Introduction to Python" tutorial.

    Python/C Integration

    Tutor: Mark Lutz, Coral Systems

    In this tutorial, students will be introduced to Python/C integration fundamentals. Although Python is interesting all by itself, its role as a scripting language owes as much to its integration tools, as to the language. This tutorial's goal is to give you the basic skills needed to start deploying Python as a scripting tool in larger systems.

    In general terms, Python programs can be both:

    • Extended with (call to) components written in a C-like language
    • Embedded in (called from) programs written in a language like C

    Extending is commonly used to integrate libraries and optimize systems, while embedding supports customizations, callback schemes, and so on. The tutorial will show how to implement both integration modes, and combine them for each application's unique requirements. Some of the topics this tutorial will discuss include:

    • Writing C extension modules
    • Writing C extension types
    • Calling Python objects from C
    • Running Python code strings from C
    • Registering code through an extension
    • Linking and binding techniques
    • Integration issues under C++
    and all the associated API details: data conversions, error handling, etc. We'll also take a brief look at automated integration tools.

    Prerequisites: This tutorial assumes students have a basic understanding of C development. Ideally, students will also be acquainted with Python language basics (some examples include Python code), but this is optional. Finally, students are encouraged to also sign up for the SWIG tutorial in the afternoon; since SWIG automates many of the tasks we'll study, in some ways it is a continuation of the ideas we'll discuss in the morning.

    Introduction to CGI programming in Python

    Tutor: Aaron Watters, Lucent Technologies

    This tutorial will introduce the basic concepts of the Hypertext Transfer Protocol Common Gateway Interface programming (HTTP CGI programming). CGI programming is the mechanism that supports many dynamic World Wide Web interactions such as query engines and forms. The tutorial will cover the basics of the protocol, as well as how to implement and test CGI processing programs using Python and its standard libraries. Advanced topics such as "cookies", file upload, authentication, redirects, and cross-platform considerations will be covered as well.

    Introduction to Python

    Tutor: Paul F. Dubois, Lawrence Livermore National Laboratory

    Learning Python

  • How to get it, install it, and learn about it.
  • Quick Tour

  • Programs
  • Modules
  • Classes
  • Procedures
  • Polymorphism
  • Statements
  • Basic types
  • Extension objects
  • But wait, there's more...

  • A survey of the Python library
  • The numerical extension
  • Complete Examples

  • History Package
  • Numerical example
  • dubois1@llnl.gov

    Python and COM (Microsoft's Component Object Model)

    Tutors: Greg Stein, Microsoft; and Mark Hammond, Australia

    This tutorial will cover the basics of COM, and how it relates to Python. The core COM concepts will be discussed, and the architecture of the core Python/COM support discussed in detail. The supporting Python library, and "COM Extension" modules (such as Active Scripting or MAPI), along with how SWIG can be used, will also be covered. In addition, practical examples of using COM objects with Python (using Microsoft Office), and implementing COM objects using Python (and using them from VB) will be shown.

    Beyond CGI

    Tutor: Jim Fulton, Digital Creations

    This tutorial will present an overview of options for server-side web programming other than CGI and will provide a detailed tutorial on the tools collectively known as "Bobo". The tutorial will cover the following topics:

    Background

    • Overview of CGI, what's good, what's bad,
    • Overview of CGI alternatives.

    Publishing objects on the web using Bobo

    • The Python Object Publisher, an HTTP ORB for Python,
    • Creating dynamic HTML pages with Document Templates
    • Creating persistent applications with a pickle-based persistent object system.