Revision 15 as of 2005-02-02 07:00:54

Clear message

Anchor(1) #1. Python in the IT Field

Greg Lindstrom / NovaSys Health ([http://www.novasyshealth.com])

In business, customer service is the name of the game. In the Information Technology field, this service manifests itself in the ability to accept, format, store, and analyze data. At NovaSys Health, we selected Python for our programming needs because it's easy to use, plays well with a variety of platforms (not only different operating systems, but a wide variety of databases) and the Python community is as helpful as it gets. This talk will discuss how Python is allowing us to list technology as a competitive advantage (accessing MS SQL database, teaching other techies, using Python's standard library).

Anchor(4) #4. MissionEngine: Multi-system integration using Python in the Tactical Language Project

Prasan Samtani ([http://www.isi.edu/~samtani]), Hannes Vilhjalmsson ([http://www.isi.edu/~hannes])

University of Southern California - Information Sciences Institute (USC/ISI)

Project homepage URL: http://www.tacticallanguage.com

The Tactical Language Training system is designed to help learners acquire communicative competence in spoken Arabic and other languages. Learners practice vocabulary items and learn gestures, following which they apply them in a simulated Mission Environment. In the simulation environment, users interact with the systemís onscreen characters using a speech recognition interface. The simulation environment is built on the Unreal tournament Game Engine.

In the past several months, a major transition has been made from the original system in Java, to a new Python-centric architecture. This presentation traces the evolution of the Tactical Language Training System from a set of separate programs to a single integrated system. The various different system components will be introduced, and the underlying technology behind will be briefly discussed. We will go over what features of the language we found especially useful for integration (latent-typing, lambda functions, pickle), and some hurdles we found particularly tricky coming from a C++/Java background.

The talk will also address the way we tackled the problem of talking to incompatible languages. For example, Unreal Tournament uses a proprietary scripting language - UnrealScript - and in order to communicate with Unreal we had to make use of an earlier ISI technology called GAMEBOTS, which is implemented both in Python and UnrealScript, and uses sockets as a method of communication.

Other topics discussed in the context of Tactical Language will adress the performance issue (writing expensive routines - the speech recognition and NLP algorithms - in C and authoring extension modules), the importance of using a powerful language for build scripts, using algorithmic optimizations over language micro-optimizations and the importance of Python's standard library in speeding up the development process.

Anchor(7) #7. Happy Hooking: Designing Software for Extensibility and Customization

Ed Leafe / The Dabo Project

It is rare for anyone to create any non-trivial software project that will not need customization at some point. It is therefore wise to plan for this when designing your code by inserting hook methods that are designed to be customized to add additional functionality later on. By default these methods do nothing, so they can be freely overridden by others without the risk of losing a critical behavior because a superclass method had been overridden. This is especially useful for creators of frameworks and tools that can be extended by their users. As one of the two primary authors of the Dabo framework, I am especially aware that in order to be useful, the code I create needs to be adapted and augmented by developers who build their apps with Dabo. I will show several code examples from Dabo to illustrate my points.

Anchor(9) #9. Dabo, the 3-tier Database Application Framework)

Ed Leafe / The Dabo Project

There are several tools available that help a developer create applications for working with data: Visual FoxPro, Visual Basic, Delphi, etc. They make some of the tedious parts of the app, such as ensuring that a change to a value in a text box gets propagated back to the correct column in the correct record of the correct table in the correct database on the correct host. These tools all have their strengths and weaknesses, but none are Open Source, and none are in Python!

In March 2004, two long-time Visual FoxPro developers, Ed Leafe and Paul McNett, had both become convinced that Python and cross-platform apps represented the future. Trouble was that there wasn't a tool available that could do what we wanted; so as a result, we decided to create our own.

Dabo is designed to create true 3-tier apps, in which the UI, the business rules, and the data storage are cleanly separated, using a Chain of Responsibility pattern for the messaging between tiers. We've chosen wxPython as our initial UI toolkit, but have written our UI classes so that their interfaces are not wxPython-specific. We currently support MySQL and Firebird on the backend, with PostgreSQL support nearly complete.

Anchor(10) #10. Agile Testing with Python Test Frameworks

Grig Gheorghiu / Avamar

I present various test frameworks that are either written in Python or use Python/Jython as their scripting language. I discuss these frameworks in the context of agile testing. Here is a high-level view of the talk I'll give:

1. What is agile testing?

2. Why Python?

3. MAIN SECTION: Python-based test frameworks

4. Jython and Dynamic Java

Anchor(11) #11. Localized Type-Inference in Python

Brett Cannon / Cal Poly SLO

This talk will present research into type inferencing in Python. The main goal of this work is to extract a performance gain from type-specific opcodes added to Python's VM. The type information needed to use these new opcodes during code generation comes about from a simple, localized type inferencing algorithm. The design of this algorithm required that no changed be made to the semantics of Python. Because of this requirement the type inference algorithm is hindered by Python's dynamic nature. This talk will discuss what in Python's semantics makes type inferencing difficult, the algorithm used, the added opcodes, and the results of adding the new opcodes.

Anchor(12) #12. The Roundup Issue Tracker

Richard Jones / Common Ground

Roundup is a simple-to-use and -install issue-tracking system with command-line, web and e-mail interfaces. It is based on the winning design from Ka-Ping Yee in the Software Carpentry "Track" design competition. This presentation will cover:

Anchor(14) #14. Documentation Costs Avoided using Python and other Open Standards

Andrew Fine / Honeywell

When I started out, I did not have any experience at SGML, XML, or other markup languages. It was only when I was perilously close to reinventing the concept of markup languages, by adapting direct PythonCOM to Word interfaces from Mark Hammond's book, that I decided there had be a better way to do this from a design and maintenance standpoint.

A Web search provided me with a crash education on markup languages such as XML, HTML, and SGML, on how DocBook SGML was an overwhelmingly popular open standard, and on how an open source package named OpenJade could translate a DocBook SGML file into Word Rich Text file.

The arrangement wasn't perfect but I realized two things: 1) it could save me a year in development and maintenance, and 2) I could respond rapidly to new assignments.

The purpose of this paper is to show how I integrated Python, DocBook, and Word together to obtain the perfection my local organization demanded.

Anchor(15) #15. Scripting the Mac with Python

Jacob Kaplan-Moss

The concept of "scripting" is central to the Unix philosophy, but it's always had spotty support in GUI operating systems. Early in the Mac OS's history, Apple recognized this deficiency and developed a framework for scripting GUI applications. Although this framework is quite well designed, its native language is not; AppleScript has been called the only "read-only" language in existence. With newly developed hooks into Apple's scripting framework, Python now gives a far superior environment for scripting. This talk will focus on using the latest and greatest Python-AppleScript bridge, appscript_, to script OSX.

Previous knowledge of AppleScript is not necessary; although this talk will briefly cover reasons why AppleScript coders should switch to Python, the bulk of the talk will be spent explaining how to use appscript_ through a series of (increasingly complex) examples.

.. _appscript: http://freespace.virgin.net/hamish.sanderson/appscript.html

Anchor(16) #16. Python for Series 60

Erik Smartt / Nokia

UPDATE 2005-01-04:

A presentation where the Product Manager and one of the engineers do a joint presentation to quickly introduce and demonstrate the port, then cover the technical issues of porting and developing extensions.

Anchor(17) #17. Durus: A Persistence System

David Binger / MEMS Exchange

The presentation will describe Durus, a light-weight system for maintaining a persistent collection of instances. Durus features transaction management, support for multiple connections with caches, common data structures, and source code that is small and readable.

Anchor(18) #18. matplotlib - from brain surgery to rocket science

John Hunter and Perry Greenfield / University of Chicago and STScI

matplotlib is a 2D graphics package written in Python. The design of matplotlib allows a wide variety of uses: you can create plots interactively from the shell, generate plots from scripts in a web application server, create animated or dynamic plots for instrument control, or embed them in the Python GUI of your choice. Unlike other plotting solutions for Python, which are wrappers of libraries from other languages, matplotlib is written primarily in Python, with calls to extension code for special purposes. Thus it is much easier for Python users to become developers, and matplotlib has an active community of developers who contribute to the code base. Originally designed to allow a user coming from Matlab to generate plots with a similar syntax and quality as Matlab, matplotlib now embraces the best ideas from Python, IDL, gnuplot and Matlab in the pylab interface, which is a procedural wrapper around the core object oriented API.

matplotlib is an array plotting package, and is codeveloped with the developers of numarray at STScI and has full compatibility with the Numeric and numarray array packages at the Python and extension code levels. The abstract class hierarchy is separated from the backend rendering layer, allowing the same pylab scripts to generate identical plots in GTK, WX, Tkinter and FLTK, including event handling such as mouse motion and clicks, as well as generate image output in postscript, SVG, PNG and other formats. It is fully integrated with the interactive Python shell ipython, which runs the GUI mainloops of GTK and WX in a separate thread, allowing interactive control of plots typical in packages such as Matlab and Mathematica.

There is support for most of the standard things people want to do with 2D plotting, with a special emphasis on scientific plots, including images, line plots, scatter plots, histograms, bar charts, errorbars, polar and log scaling, contouring, financial charts, legends, mathematical text with a built-in TeX math expression parser, freetype2, W3C compliant cross-platform font-management, and more. matplotlib is highly configurable, with the default appearance of every plot element controlled by a configuration file, and all of the plot elements readily customizable.

Anchor(19) #19. Studying African Lions in the Serengeti Ecosystem with Python

Michael Urban / Lion Research Center ([http://www.lionresearch.org])

The Lion Research Center, headquartered at the University of Minnesota, is responsible for the Serengeti Lion Project in Tanzania, Africa, and is known throughout the world as a leading institution in the research of African lions. In this presentation, I will discuss FELIS, which is software we developed entirely in Python for identifying, tracking, and analyzing data on African lions in the Serengeti National Park, Ngorongoro Crater, and other lion projects in Tanzania. The software uses a pyGTK interface, and uses data from multiple sources. The software stores its native data using pysqlite. However, the software is also capable of cross-referencing its own data with additional data stored in Access databases, and Excel spreadsheets by using the mxODBC module. In addition, the software includes image processing capabilities for storing and viewing photographs of lions using the Python Imaging Library. Thanks to Python, we are now able to identify lions must faster and with much greater accuracy than was possible before; extract information based on multiple data sources in seconds that used to take days to extract manually; and easily share data between field researchers in Tanzania and our researchers at our headquarters at the University of Minnesota. Python has really revolutionized the way we study African lions.

Anchor(20) #20. Fast Networking with Python

Itamar Shtull-Trauring

This talk would cover three topics, each leading into the next. While the examples are mostly Twisted specific in the first two parts, the general concepts are relevant to Python networking specifically and Python programming in general.

1. Algorithms are very important when attempting to write fast code, including networking. The talk will cover buffering and string manipulation, and possibly scheduling, and common mistakes that can make code orders of magnitude slower. Examples will include Twisted's buffering algorithm rewrite between 1.3 and 2.0, use of buffer(), imaplib, and maybe comparision of scheduling algorithms between Twisted 1.3, 2.0 and glib (where Python code is faster than C code due to a superior alogrithm).

2. This part of the talk will explain Python's limitations - reads from sockets/files always allocate memory, lack of good byte array datatype, general slowness - and show how C or C++ can be used to circumvent these issues. As an example I will cover Fusion, an open source C++ integration layer for Twisted, and show how it solves some of the issues Python has. I will also cover the problems caused by using C or C++ code.

3. In the final part of the talk, I would like to cover possible improvements to Python (specifically socket and file objects) that together with the need for a new builtin type, a byte array, would allow gaining some of the speed benefits available when using C/C++.

Anchor(21) #21. Intuition and Python Programming - the Python Visual Sandbox

Michael Weigend / Holzkamp-Gesamtschule Witten, Germany

When you write a Python program, search for semantic errors, proof the correctness of a function or just talk about programming, you use intuitive models of information processing. An intuitive model is a mental concept which is simple and self evident and needs no further explanation. Usually these concepts can be visualized. Intuitive models can be useful or they can be misleading. Sometimes they are unconscious. The Python Visual Sandbox (PVS) is a collection of interactive multimedia applications ñ usually games, especially designed for programming novices. They contain more than a hundred animations which represent intuitive models including typical misconceptions. The purpose of the PVS is two fold. First of all it is a research tool to find out, what intuitive concepts Python programmers use in different contexts. Secondly it is a learning device which can be integrated in lesson plans. This contribution focuses on the learning/teaching aspect.

Anchor(22) #22. Extreme Programming with Python in the Classroom

Michael Weigend / Holzkamp-Gesamtschule Witten, Germany

Extreme Programming (XP) and Python seem to fit in several ways to the goals, needs and conditions of informatics teaching at high school. In this contribution I present class room examples to illustrate how teachers could adopt XP methodology to design successful informatics lesson plans.

Anchor(24) #24. Decimal data type

[http://www.taniquetil.com.ar/plog Facundo Batista]

In the paper I'll explain what is Decimal, how to use it, and when to use it. The idea is to let the reader to feel confident about this new data type in order to start using it.

I'll start with the detail of the Decimal intrinsic structure (floating point, bounded precision), the major differences with binary floating point, and other advantages.

Later I'll show how to use the module, from the simplest way (just use it) to a more advanced interaction (from showing its methods to explain how to use the Context, including rounding methods, signals, etc.).

Finally, I'll present some cases to show when use and not use Decimal instead of binary floating point.

Anchor(25) #25. MultiDrizzle: Astronomical Image Analysis Software for Python

Warren J. Hack / Space Telescope Science Institute

Multidrizzle began as a collection of FORTRAN code and IRAF scripts for the combination of Hubble Space Telescope imaging data.

PYFITS, and PyRAF, we have developed a robust piece of software, in less than one year, that will become the primary tool in the Advanced Camera for Surveys (ACS) data reduction pipeline for image combination and cosmic-ray cleaning. This same software has also been made available for use by researchers to reduce their ACS data on their own systems. We will describe the motivations for moving the existing Multidrizzle code to Python, highlight the challenges that NUMARRAY, PYFITS, and PyRAF allowed us to overcome, and illustrate how it serves as a primary task in a developing astronomical data analysis suite for Python.

Anchor(26) #26. An Introduction to building Chandler parcels

Ted Leung, Katie Capps Parlante / Open Source Applications Foundation

Chandler aspires to be an innovative open source personal information manager (PIM). In addition to being written in Python, Chandler is using the following open source libraries: BerkeleyDB, M2Crypto, Twisted, pyLucene, and wxPython/wxWidgets. Chandler is designed to be an extensible PIM. Chandler's unit of extensiblity is called a parcel, and Chandler's "built-in" functionality is itself composed of parcels. Internally, Chandler is designed as layers of frameworks which provide applications functionality to parcels. Parcels communicate with each other via the data in the Chandler repository.

The goal of our presentation and paper is to allow someone to begin developing a parcel that extends the Chandler user interface.

Anchor(27) #27. Pulling Java Lucene into Python: [http://pylucene.osafoundation.org PyLucene]

Andi Vajda / Open Source Applications Foundation

As we needed an open source text search engine library for our Python based project, we made the following bet: what if we pulled together Java Lucene, GNU's gcj java compiler and SWIG to build a python extension ? In this presentation we'd like to talk about the challenges we met since this project was started a year ago.

Anchor(29) #29. A Layered Event System to Provide Method Extensibility

Jim Fulton / Zope Corporation

Developers often want to extend the behavior of existing software. For example, a developer might have a class that manages data or provides some functionality and want to provide a user interface for it. Similarly, a developer may want to incorporate an object into a framework and may need to provide additional interfaces to integrate it. We've found that adaptation works well in situations like these.

Sometimes, there is a need to extend what happens *inside* individual methods. For example, when an object is added to a system, we might record meta data or index the object's data or meta data. The actions we want to take are likely to be application dependent. It shouldn't be the responsibility of the code that adds the object to take these extra actions. Rather, to address situations like this, we use events and subscribers. Events signal that something has happened and subscribers can be registered to perform extra computation when something happens, thus extending the methods generating the events.

This event system is related to and addresses some of the same needs as Aspect-Oriented Programming (AOP). Events are equivalent to AOP point-cuts and subscribers correspond to advice. Unlike AOP, events are explicitly introduced into application code. An AOP system might be built on top of this event system by providing tools that automatically inject events into applications.

An event system provides a very elegant way to implement hooks. Any system that uses hooks can be simplified and made more flexible with events.

Zope has a layered event system, built on an extremely simple policy-free base. Additional layers, built on this base layer, progressively add additional policy. Zope provides an adapter-based subscription framework that provides a simple rule-based system.

The basic event system would make an extremely trivial, but very useful addition to the Python standard library.

In this presentation, I'll discuss the motivation for, and applications of, events. I'll give a number of event application examples including the use of event subscribers to add layers of policy to the underlying event system.

Anchor(30) #30. State of Zope

Jim Fulton / Zope Corporation

A discussion of the current state of Zope, covering developments in the past year and plans for the future.

Anchor(32) #32. Descriptors: From functional wart to decorator madness via properties

Mike C. Fletcher / Cain Gang Inc.

This presentation introduces the beginning/intermediate Python programmer to the Descriptor API, from its origins in the functions-are-special-cases "wart" in Python 2.1 through the introduction of the attribute-access API in Python 2.2 and to the introduction of function-decorator support in Python 2.4 and the expected Cambrian explosion of decorator classes. We will discuss some of the mechanics of the descriptor API, then focus on "why and when" to use descriptors and decorators.

Anchor(33) #33. Design Patterns and Python OOP: Objects by Design

Alex Martelli

Python is multi-paradigm; however, Object-Oriented Programming (OOP) is Python's core paradigm, and an understanding of Design Patterns (DP) and of how to best use them is a key enabling skill in doing effective OO development. This presentation takes its contents mostly from the OO chapter of the Python Cookbook (2nd Edition), and focuses on Design Patterns and related idioms presented there, with expanded explanations of underlying language mechanisms and additional examples.

Some classic DPs are practically "built-in" to Python. Other patterns can be just as useful in Python as in other languages, if you know them well and apply them deliberately to structure your design; moreover, there are language-specific issues and opportunities, connected to such patterns, which it's important to understand fully. Other patterns yet are generally inappropriate for use in Python applications, and may be best replaced by Python-specific idioms.

Exactly because Python is multi-paradigm, it empowers you to make meaningful design choices; and, as usual, with power comes responsibility -- you need solid, in-depth understanding of what choices you have available, and of what implications and consequences such choices have, to choose for the best.

When should you use a closure, rather than a class with callable instances? Where is inheritance appropriate, and where is it better to use containment and delegation instead? When should you define 'slots', what exactly are the implications of doing so, and what alternatives approaches may often be preferable? The purpose of this presentation is also to explore this kind of questions, and to provide the fundamental knowledge and the outlook that will help you answer the questions in the most useful ways for your own applications.

Anchor(34) #34. Cross Platform Desktop Applications with Python

Nathan R. Yergler / Creative Commons

In 2004 Creative Commons began to expand their offerings to include client applications. The applications were intended to promote and complement the licenses offered by Creative Commons. After evaluating other languages, Python was chosen as the primary development language, and wxPython was chosen as the user interface toolkit. ccPublisher is the outgrowth of these early decisions.

Today the Creative Commons is preparing to ship ccPublisher 1.0 on Mac OS X, Windows, and Linux. Python and wxPython, along with a fair amount of code manipulation, have enabled us to create a single code base for all three platforms. This code base, along with a set of build tools which are also being released as Open Source software, allow developers to focus on writing quality applications which integrate well and look "right" on all platforms. The overriding goal has been to isolate platform-specific code and settings, in an effort to share as much code as possible.

This presentation will focus on the non-intuitive aspects of cross-platform development with Python and wxPython. We all know that Python is available for a wide variety of platforms, but what goes into creating an application that doesn't require end-users to be aware of dependencies or languages? In particular, this presentation will cover handling platform-specific GUI idioms (Mac OS X menu bars, drag and drop on all platforms, etc), creating distributions of your application (MSI for Windows, DMG for OS X, RPM/DEB for Linux) which bundle all the necessary dependencies and which install seamlessly, and inconsistencies and problem areas we have encountered during the development of our applications. The presentation will also present some "best practices" developed during the project which have proven useful in minimizing the effort required to add features and refactor a cross platform application.

This presentation will be of interest to any Python developer considering developing end user applications with Python. It would also be useful for developers looking for easier ways to manage their building and distribution process.

Anchor(35) #35. Integrating RDF in Python Applications

Nathan R. Yergler / Creative Commons

The Resource Description Framework, RDF, is an exciting and largely mis-understood area of Internet development. RDF allows developers to represent complex relationships in a way which other applications can understand, often without prior knowledge of schema or datatypes. Today RDF engines exist in many mainstream applications such as Mozilla, largely untapped by developers.

Python has excellent RDF support libraries available, and therefore should be an excellent platform for developing intelligent applications.

misconceptions about RDF, providing an overview of the Python libraries which support RDF, and demonstrating a real world usage of RDF in a Python application. The discussion of Python RDF support will also highlight shortcomings and potential pitfalls associated with RDF development. Brief attention will be given to current RDF developments if time remains.

This presentation will be useful for any developer working on integrating two or more applications, and to any developer interested in leveraging future web developments. Developers will leave the presentation with a firm understanding of what RDF is and how they may use it in their applications.

About the presenter: Nathan Yergler is a Software Engineer with Creative Commons. The primary developer of mozCC, ccPublisher and ccLookup, he has been manipulating RDF for the past 18 months in an effort to provide human-level integration between applications and the ethereal Semantic Web. During that time he has become intimately familiar with Python's RDF offerings, and widely frustrated by his own misconceptions. He wishes he knew then what he knows now about RDF.

Anchor(36) #36. Descriptors, Decorators, Metaclasses: Python's "Black Magic"?

Alex Martelli

Python's versions since 2.2 have introduced, enhanced, and clarified some new advanced mechanisms: two of them are the underpinnings of Python's Object-Oriented Programming (OOP), Descriptors and Metaclasses; one, introduced in 2.4, is a syntax for the systematic application of an important use case for higher-order functions. This presentation takes its contents mostly from the (informally known as...) "Black Magic" chapter of the Python Cookbook (2nd Edition), also known (official chapter title!) as "Descriptors, Decorators and Metaclasses", and focuses on some of the most interesting applications and related idioms presented there, with expanded explanations of the underlying language mechanisms and additional examples.

_Descriptors_ control and guide attribute access. Python offers several built-in descriptor types -- for example, in today's Python, _functions_ are descriptors -- and also lets you code your own.

_Decorators_ are a simple syntax to feed a function as the argument to another (higher-order) function, and have the latter's resulting value used in lieu of the original function -- while decorator syntax ('@deco') is new in Python 2.4, you can use the same approach with slightly clumsier syntax ('func = deco(func)') in 2.3 and even 2.2.

_Metaclasses_ are to classes as classes are to instances. Python's built-in metaclass is the built-in 'type', and you can subclass and customize it to produce custom metaclasses to control behavior of whole family of classes.

This presentation shows how to best use each of these mechanisms, both in terms of existing, Python-supplied objects and types (descriptors, decorators and metaclasses), and of coding and using your own custom ones. What are "data" and "non-data" descriptors, and how and why might you code and use either kind? When do you need introspection to ensure proprer decoration, and how can Python's standard library help there? How should custom metaclasses cooperate to insure peaceful coexistence of several of them, and how can you solve metatype-conflicts? And, of course -- how do custom descriptors, decorators, and metaclasses cooperate with each other, and with other powerful Python mechanisms such as introspection, closures and advanced dynamic gyrations, to let you write elegant and powerfully customized code with minimal effort? This presentation explores this kind of questions, providing the fundamental knowledge and the outlook that will help you answer the questions in the most useful ways for your own applications.

Anchor(37) #37. Iterators and Generators: it ain't your gramps' loop any more!

Alex Martelli

Python's versions since 2.2 have introduced, enhanced, and clarified the *iterator protocol*, which describes how items are produced one after the other, in sequence, typically for use in a 'for' statement, and supporting mechanisms -- generators, the itertools module of the standard library, and now, in 2.4, _generator expressions_, which can be seen as a merge between list comprehensions and generators. This presentation takes its contents mostly from the "Iterators and Geerators" chapter of the Python Cookbook (2nd Edition), and focuses on some of the most interesting applications and related idioms presented there, with expanded explanations of the underlying language mechanisms and additional examples.

An _iterator_ is any object supplying a 'next' method, callable without arguments, that satisfies certain conditions. A _generator function_ is a function which uses the 'yield' keyword to return a _generator iterator_ object, whose 'next' method is based on suspending and resuming the function's execution. The itertools module supplies several powerful 'building blocks' to deal with iterables (including iterators and generators) and to produce them -- itertools lets you program at a very high abstraction level while _increasing_ your code's performance (an 'abstraction BONUS', rather than the abstraction *penalty* which is more common in other languages). Generator expressions are like list comprehensions which produce their results one item at a time, via an iterator, without taking up the memory needed to store all results at once.

This presentation shows how to best use each of these mechanisms to make your control structures reusable and simplify your application level code -- by abstracting recursion and other rich and complicated iteration mechanisms into generators and the like. How can you repeat something 17 times, _faster_ than by 'for i in xrange(17):'? How do you tame unbounded (infinite) sequences to your purposes? How can you "peek ahead" into an iterator without disturbing its iteration-state? This presentation explores this kind of questions, providing the fundamental knowledge and the outlook that will help you answer the questions in the most useful ways for your own applications.

Anchor(39) #39. How to Build an Air Traffic Control System

Neal Norwitz / MetaSlash

I've been working on creating a new ATC system. Of course, it had to be written in Python. :-) It also uses Twisted and the Tk canvas widget.

aircraft and features of an airspace, such as waypoints, routes, restricted areas, etc.

Anchor(40) #40. What is the PSF

Neal Norwitz / MetaSlash

I would like to request that a time slot be reserved for someone (not me) to make a presentation about what the PSF is, its benefits, direction, etc.

Anchor(42) #42. Keep It Simple with PythonCard

Kevin Altis

In this session, Kevin Altis will demonstrate the process of building cross-platform Python applications with graphical user interfaces using the PythonCard framework and tool set. By giving you access to the full power of Python without requiring you to master complex GUI libraries, PythonCard becomes a power tool for scripting users and professional programmers alike. Creating graphical desktop applications that run across platforms and take advantage of Python's simple elegance is easier than you think. And PyCrust, the embeddable Python shell, puts the power of the Python interpreter at your fingertips.

Anchor(43) #43. Breaking the Rules of Commercial Software Development : Why and How we used Python to Produce a New Deal in Payroll Software.

John Pinner / Clockwork Software Systems

Applications like accounts and payroll are the lifeblood of real world businesses. These applications are usually proprietary and subject to the usual proprietary software licencing mechanisms.

PayThyme is a brand new UK statutory payroll application, the first genuinely new payroll software for some time, and the first Open Source UK payroll.

Commercially PayThyme breaks new ground in almost every respect : it is the first UK native GNU/Linux payroll, and it has no built-in licence quota on numbers of users, numbers of employees and numbers of payrolls, all of which are restricted in most commercial payrolls. Furthermore, there is just one version of PayThyme, suitable for both the smallest and largest of payrolls, as opposed to existing software which is usually targetted in both capability and price at specific market levels. This allows your payroll to grow with your business. To further confuse conventional business software developers, PayThyme is licensed under the GPL and is available as a free download.

Technically, PayThyme is also unusual. It uses the Thyme development platform, which is itself Open Source and based on Python and the PyQt GUI platform. A novel set of data-aware widgets links GUI screens (originated in Qt Designer) with Thyme's database filing system, allowing rapid object-oriented application development. The product was developed by a small core team of three people working remotely using a central Subversion repository. The user interface is implemented entirely in Python.

PayThyme takes advantage of Python's rich set of extension modules, for example in implementing Internet Filing of end-of-year returns to the Inland Revenue via the UK Government Gateway.

Anchor(44) #44. Object-oriented design with Python

Bruce Eckel / www.MindView.net

This session presents general object-oriented design principles, but focuses on object design issues where Python is distinct from mainstream statically-typed languages.

For example: What kinds of Lightweight design tools make sense in Python, and which does Python obviate? What would it mean to have interfaces in Python, and what sort of features would be valuable? Since Python produces smaller code, can objects be bigger? Tradeoffs in static vs. dynamic type checking on design and implementation. What you can do in the constructor vs statically-typed languages.

Not rules, but guidelines and ideas presented for discussion: Interface inheritance vs. implementation inheritance, substitution vs extension, the impact of Python on these concepts. Partitioning your design into objects. Not enough objects and objects that are too big/complex. Creating robust objects. Wiring together objects to create an application. Design by contract; Base classes as interfaces with constraints. Preferring composition to inheritance.

Design patterns issues: Which design patterns in GoF are so C++-ish that they don't make sense in Python? Does the Visitor design pattern have any relevance in Python? Built-in design patterns: Generators (special case of factories). Python and the homogeneity problem (Composite pattern, using isinstance).

An OpenSpace discussion will follow as soon after the session as availability permits.

Bio: http://mindview.net/Etc/About/about.html

Anchor(45) #45. py.test and the py lib

holger krekel / merlinux GmbH

Authors: Holger Krekel, Armin Rigo

We present a novel testing tool which allows to write unit tests with hardly any boilerplate. Unlike the many JUnit clones, py.test lets you use the plain assert statement. If failing, you get a convenient anaylsis of intermediate values in the assert's expression. Example: 

def f(): 
   return 23

def test_something(): 
   assert 42 == f()

is the full content of a file that you can run with py.test: no imports, no inheriting classes or other magic incantations needed. Just write a global function that starts with 'test_' and run py.test on that file. You will see in the py.test generated traceback that "42 == 23" failed. Reusing the 'assert' statement is actually closer to the mother of JUnit/testing: SUnit from the Smalltalk world.

For the failing assert expression we use a hack to directly re-interpret its Syntax Tree. This is a limited AST-Mini-Interpreter, as it can only interpret expressions and a number of statements but luckily this is more than enough to give you precise clues for why a test fails at a certain assertion.

Generally, testing is a perfect match to control and make full use of Python's flexibility. But unfortunately, the testing mechanisms of most python projects are more or less entangled hacks around unittest.py. We think that we can and should do better than this.

Basically py.test aims to provide a new integrated and pythonic test environment which enables _sharing_ of common testing support code, such as HTML and PDF reporters, GUIs and customization or mock-object facilities.

But there is more. Apart from the user-exposed test facilities and features the py lib contains higher level introspection classes, support for dynamic code generation, a new approach to distribute python code across networks and processes, and a "Path" abstraction allowing uniform access to the local file system, subversion file systems or remote Path objects through e.g. SSH connections. We'll see if there is enough time to talk about all of the latter (otherwise we intend to do lightning talk demonstrations).

Anchor(46) #46. The Compete File System: File System Virtualization using Python

Christopher Gillett / Compete, Inc.

The Compete File System (CFS) is a file management and file system virtualization software layer and Unix command set. CFS provides a framework for distributing files across multiple file systems while allowing the end-user or software developer the convenience of viewing the multiple systems as though they were a single large file system. Internally, CFS uses load balancing and server scheduling algorithms to provide maximum file system space availability while maintaining file server performance. CFS provides this functionality while still remaining in user application space - modifications to the operating system kernel are not necessary, and CFS never needs to operate in kernel or protected mode. In fact, to the extent that the underlying physical file systems can map to the local host's file system, CFS is largely system and platform independent.

CFS is written entirely in Python. The ability to develop high quality code extremely rapidly using Python combined with the depth and sophistication of the Python runtime system allowed a very small team to create this powerful system-level software package very quickly.

Anchor(47) #47. Query-directed Data Mining using Python and Parallel Processing

Christopher Gillett / Compete, Inc.

Compete, Inc. has built a query processing system using Python which forms the basis for all query-directed data mining within our company. The system accepts queries written in "near SQL" syntax and performs parsing and analysis of the queries. Query decomposition allows exploitation of parallel computing resources and allows queries involving large amounts of data to be answered comparatively quickly.

The system was built entirely using Python and is used in conjunction with the Portable Batch System and various Unix utilities.

Anchor(49) #49. Profiling and Visualizing Python Program Behavior

Clinton Jeffery / NMSU

This talk gives a brief overview of Python's facilities for profiling and debugging, and then presents a new architecture (ULMA -- Ultra-Light Monitor Architecture) for program execution monitoring. We have implemented an initial set of ULMA facilities by extending and adding instrumentation to the Python interpreter. Execution behavior information is delivered via shared memory to monitor(s) written in C, Python, or Unicon.

Anchor(50) #50. Decimal Module for Beginners

Michael Chermside / ING Direct

This is an introduction to the new decimal module. It endeavors to explain why we might want support for decimal floating point in Python, and then provides some examples of its use. If you have read PEP 327 and perhaps played around with the module once or twice, then you probably already know everything covered in this talk, but if you have heard that there was a decimal module and are curious, or if you think you might want to use such a thing but aren't really sure, then this is for you.

Anchor(51) #51. Sequential code in an event-driven world

Nat Goodspeed / [http://www.solidworks.com SolidWorks Corporation]

In an event-driven system such as a game environment, it's common to want to start some action, such as an animation, that will run for several frames. But in an event-driven system, control reaches the same entry point over and over again. There are various ways to ensure that the right code is executed for each frame -- but using Python generators makes it remarkably natural and readable.

This talk presents the Animator class, along with its friends and relatives TimeAnimator, Sequencer and AlarmClock.

Anchor(53) #53. Writing Efficient Rule-Driven Software in Python

Phillip J. Eby / Telecommunity Consultants

In the design of applications, rules are everywhere: business rules, game rules, routing rules, "expert systems", code and query optimizers, and rule-based "agents" and triggers. But to implement rules, they have to be converted into code -- usually in the form of decision trees that become increasingly difficult to maintain as the number of rules grows. Recent developments in computer science, however, make it possible to automatically convert rules into decision trees that are guaranteed to be correct and efficient, even for large numbers of rules, without using a specialized logic or rule language like Prolog or Lisp. This presentation will give an overview of how to implement rule-driven systems directly in Python, using Python itself as the language for specifying rules, with faster development and execution times than would be obtained by hand-coding if-then trees. Examples will be based on the predicate dispatch implementation included in the latest version of the PyProtocols package.

Anchor(55) #55. SchoolBell: a Zope 3 Calendar Server

Tom Hoffman / SchoolTool

SchoolBell is an open source calendar server for small to medium sized organizations, written for Zope 3. Each person, group or resource has a calendar accessible via an HTML interface. A user can integrate events from other people or groups into their calendar. iCalendar support allows interoperability with clients like Mozilla Calendar and Apple's iCal. Access control can be set for each calendar to allow events to be viewed or added by specific users or groups.

SchoolBell is also a Zope 3 application that breaks out of the Zope 2's "folders and documents" paradigm, instead using a directed graph data model. Application objects, such as people, groups and resources. Each object can have facets which model the object's responsibilities and encapsulate its data for a particular role that object plays in the system. Objects are connected via relationships. Each relationship's type is defined, as is each object's role in the relationship. Each object, relationship, role and facet is identified by a URI, facilitating a comprehensive REST-style web services API for all the application's functions. This architecture has broad applicability outside of calendaring.

SchoolBell is based on SchoolTool, a free IT infrastructure for schools, funded by the Shuttleworth Foundation. The initial design for SchoolTool was done by Steve Alexander of Canonical Ltd. Subsequent development has been done by Programmers of Vilnius and Etria LLC.

Project manager Tom Hoffman will begin with a tour of SchoolBell, followed by a discussion of its unique architecture led by Brian Skahan of Etria.

Anchor(56) #56. Yarn: Working with Messages in Diverse Formats and Protocols

Abe Fettig / JotSpot

People today read, write, and organize information stored in many different places, using many different formats and protocols. In the course of a single day, a person might read and send email, get the latest news through RSS, post to their weblog, create or edit a page on their Wiki, add a new site to their del.icio.us bookmarks, upload digital photos to Flickr, monitor items being sold on eBay, and check on the status of a package being shipped through UPS.

This poses a challenge for application developers. Users want their programs to be able to access their data, regardless of the system in which the data lives. But implementing support for all these formats and protocols is expensive and time consuming.

This talk introduces Yarn, a Python library that allows developers to work with a wide range of file formats, messaging systems, and web services, using a standard API. Yarn currently provides support for reading and writing RSS, Atom, OPML, mbox, and maildir files, on a local filesystem or over HTTP or SFTP; the Atom and MetaWeblog blogging APIs; IMAP, POP3, and SMTP; and web services including Google, Amazon, Flickr, del.icio.us, and UPS package tracking. Yarn provides APIs for reading, writing, and editing messages, searching, and navigating folder trees. It also includes such helpful features as metadata storage, connection sharing, caching, and credentials management. An extensible architecture makes it easy to support new formats and protocols through plug-ins.

Yarn is written in 100% pure Python, using the Twisted framework. It is currently licensed under the GPL, but will be released under a more liberal license before PyCon 2005.

This talk will introduce Yarn and show how it can be used to add powerful messaging and publishing functionality to Twisted applications.

be used to read and copy messages, even between systems that don't speak the same protocol. It will also present code examples showing to use Yarn in various ways.

Anchor(57) #57. Introduction to PyObjC

Bob Ippolito

Introduction to PyObjC is a quick tour of PyObjC suitable for anyone with Python experience looking to get their feet wet with Cocoa development with their programming language of choice. Prior Objective-C knowledge or Interface Builder experience is not necessary.

Anchor(58) #58. PyObjC Hacking

Bob Ippolito

PyObjC Hacking is a quick tour of advanced uses for PyObjC and related tools. This talk is geared toward those who have a working knowledge of PyObjC (or at least attended Introduction to PyObjC) and ideally understand data structures at the C level.

Anchor(59) #59. OpenLaszlo: A Python Success Story

Oliver Steele / Laszlo Systems, Inc.

OpenLaszlo is an open source platform for developing interactive client-side web applications. It consists of a compiler, that compiles XML with embedded JavaScript to (currently) Flash files; and a runtime XML and JavaScript library. Applications built using the Laszlo platform have been deployed on the Earthlink home page and Yahoo, among other sites.

The OpenLaszlo compiler and application optimizer were implemented in Jython. The use of Jython allowed us to implement a full-featured deployable JavaScript-to-bytecode compiler in a short amount of time (three months).

This talk will describe how Jython's introspective, interactive, and integration features enabled the use of development methodologies that made this development speed possible, and how having the compiler in Jython then allowed us to experiment with innovative new features at a rate that would have been discouraged by a static system. It will also describe the challenges of actually deploying a Jython-based solution.

Anchor(60) #60. The Time of Day

Anna Ravenscroft

This presentation will provide an overview of the options available in Python's datetime module, and some of the third-party packages such as dateutil that have been developed in response. We will explore such topics as time durations, recurrence rules, and fuzzy parsing, then tackle the intricacies of time zone support.

The presentation will start with datetime fundamentals, introducing the different kinds of datetime instances. It will explore some common problems with dates, then delve into the trickier issue of timezone support.

The presentation will provide a brief overview of the features available in two third-party packages: dateutil, which supplies a variety of handy utilities including finer manipulation of date operations, recurrence rules, and fuzzy parsing, and a form of timezone support; and pytz, which provides a convenient Python implementation of the Olson timezone library. The presentation will finish by exploring some of the issues involved in working with timezones and demonstrating of how these package deal with those issues.

The presentation is intended for beginners and intermediate pythonistas.

Anchor(61) #61. Streaming Python

Thomas Vander Stichele / Fluendo

Flumotion is a GPL streaming media server written in Python. It is distributed and component-based: every step in the streaming process (production, conversion, consumption) can be run inside a separate process on separate machines.

Flumotion uses Twisted and GStreamer. Twisted enables the high-level functionality, distributing components over the network. GStreamer, through the Python bindings, enables the high-speed low-level functionality: actual media processing.

Flumotion uses a central manager process to control the complete network; one or more worker processes distributed over machines to run actual streaming components; and one or more admin clients connecting to the manager to control it.

Flumotion is a young project under very active development. In its current release (0.1.4), it already supports the following features:

- various sources: webcams, soundcards, TV cards, Firewire cameras

- various codecs: Vorbis, Theora, mulaw, JPEG, smoke

- various containers: Multipart, Ogg

- username/password authentication

- overlaying, colorbalance

- HTTP streaming

- disk archiving

- administration GUI with a wizard for the most basic scenario

- code distribution from a central location

- local caching of the distributed code space

- strong focus on ease of use and usability

The current design allows for the following future features:

- multiple GUI's thanks to clean model/view separation in admin clients

- any number of sources/containers/codecs/effects/protocols to be added

- completely centralized code upgrades

- complete code upgrades with minimal downtime

- any kind of authentication mechanism (key exchange, challenge/response, ...)

- any number of possible scenarios for actual content production and distribution

- manager failover and state replication

- loadbalancing streams over different servers or from different locations

- internal stresstests

Some of the features are only possible or easily implementable thanks to using a high-level language like Python:

-

Unable to edit the page? See the FrontPage for instructions.