Talk Abstracts
Database Programming
Using the Python Database API
Concepts behind the Python Database API and their use in real-life applications.
Marc-André Lemburg (eGenix.com Software GmbH)
Talk, 30 minutes (Intermediate)
The talk will give an introduction to the concepts used in the Python Database API and relational databases in general. Connection, cursors and transactions are discussed, and their use in a typical Python database application are demonstrated.
Building Data Mashups with SnapLogic
This talk will provide an introduction to using the SnapLogic open source data integration framework for data mashups.
Mike Pittaro (Co Founder, SnapLogic)
Talk, 45 minutes (Intermediate)
SnapLogic is an Open Source data integration framework based on a REST architecture and implemented in Python. SnapLogic can be used as a data services framework for mashup applications and REST data services, as can also be used for analytic and operational data integration.
My talk will cover an introduction to the SnapLogic architecture, and the use of SnapLogic to create mashup style data feeds.
I will demonstrate how to use SnapLogic to create a data feed from a database, and from an application, and then combine the two data feeds, consuming the results in a mashup client like DreamFace or DBEntrance.
SnapLogic Overview (15 minutes)
SnapLogic Server Overview
- Development Model Overview
SnapLogic Components
- Connectors
- Operators
- Pipelines
SnapLogic Examples (25 minutes)
- Creating a unified view of tickets from multiple Trac instances
- Extracting data from SugarCRM into a JSON feed.
Games Programming
cocos2d, a framework for building 2d games
cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications.
Talk, 45 minutes (Intermediate)
cocos2d facilitates the making of 2D games, by providing the following features:
- Flow control: Manage the flow control between different scenes in an easy way
- Sprites: Fast and easy sprites
- Actions: Just tell sprites what you want them to do. Composable actions like move, rotate, scale and much more
- Effects: Effects like waves, twirl, lens, liquid and much more
- Tiled Maps: Support for rectangular and hexagonal tiled maps
- Transitions: Move from scene to scene with style
- Menus: Built in classes to create simple menus
- Text Rendering: Label and HTMLLabel with action support
- Documentation: Programming Guide + API Reference + Video tutorials + lots of simple tests showing how to use it
- Built-in Python Interpreter: For debugging purposes
- BSD License: Just use it
- Pyglet Based: No external dependencies.
- OpenGL Based: Hardware Acceleration.
Other
Freezing the Python
Introduction and best practices of Python applications deployment on Windows
Fabio Pliger (S3 s.r.l.)
Talk, 45 minutes (Intermediate)
It's very common to have customers who need an executable application without Python being installed on their system. Better if no new installations are involved..
This talk is, at the same time, a short introduction into the world of freezing Python code in a Windows environment into executables and a collection of best practices to handle many typical issues and user cases experienced over many years working with this need.
For the most part, the talk will touch upon arguments such as packaging dimensions, packages and dependencies issues and custom application modules updates.
Version Control for Du^H^HDevelopers
Learn why distributed version control is good for you, and how to use it to full effect.
Talk, one hour (Intermediate)
While not directly Python-related, version control should be mandatory knowledge for every single software developer out there. Knowing your tools will make you more productive and will let you concentrate more on the actual code.
Lately, decentralised version control has been all the rage. I aim to show you why, and what great benefits you will get from it, even if you work alone.
While the principles apply to any decentralized version control -- they are closer to each other than people normally expect -- I am most familiar with git, and will be talking about that.
This talk should apply equally to free software projects or for proprietary in house development.
Phatch - PHoto bATCH Processing for Everyone
Talk, 45 minutes (Intermediate)
Phatch is an easy to use GUI Photo Batch Processor both for amateurs as graphic professionals. It can batch resize, rotate, apply perspective, shadows, rounded corners, ... and more in minutes instead of hours or days if you do it manually. It can duplicate and manipulate (sub)folder hierarchies. Photos can be renamed or data stamped based on their EXIF and IPTC tags. Phatch ships with a Python API and can also run as a console version to batch photos on web servers. As such it makes the workflow for preparing web graphics an easy task. Phatch is written in 100% python, uses PIL for its backend and wxpython for its cross-platform user interface. As a visual artist and architect I have paid high attention to polishing the user interface. In my talk I will present Phatch, give a live demonstration and explain its Python internals.
Phatch runs on Linux, Windows and Mac. It is available in the repositories of Arch Linux, Debian and Ubuntu or as a source package for other systems.
You can find more information about Phatch:
website: photobatch.stani.be
documentation: photobatch.wikidot.com
PyPy - Behind the Scenes
Development and funding of PyPy past and present.
Beatrice Düring (Changemaker)
Holger Krekel (merlinux GmbH)
Talk, one hour (General)
PyPy is a five year old project aiming to deliver a flexible and fast Python Implementation along with a novel framework for implementing dynamic languages in general.
Bea and Holger talk about how PyPy development works on people and organisational levels. They'll also shed light on past and current funding of PyPy and discuss ideas and plans for the future.
Developing a Very Large Python Web Application LEAN style
How the thirty person Launchpad team at Canonical use LEAN software development practices to release every four weeks.
Steve Alexander (Canonical)
Talk, 30 minutes (Intermediate)
Steve will talk about the development processes used on the Launchpad team at Canonical, on the thirty-strong distributed team that develops a complex web application. He'll talk about the software development cycle, the tools the team uses, the kinds of meetings and planning processes, and what lessons have been learned from LEAN methodologies.
Barcamp/Open Space
Barcamp Sessions, aka 'Open Space'
Other Type of Event, Full day (General)
In a barcamp you decide what you want to do, and what talks you want to present, at the time. So what happens here is decided by the delegates, there is no organiser input.
MrTopF will be briefing us on how barcamps work at the start of EuroPython, and delegates may decide to run barcamp sessions if they wish.
Alternatively you may wish to have some Open Space sessions, like at previous EuroPythons, where people with common interests get together to discuss their projects.
Python in Action
Python and System Administration
Using Python for multi-platform sys admin
John Pinner (Clockwork Software Systems)
Tutorial, 90 minutes (Beginner)
The philosophy of Unix sysadmin was to have lots of small tools, each of which did one job well, and to provide the mechanisms to join them together to perform larger tasks. The glue joining them together was the Bourne shell. Generations of Unix system programmers used Bourne with the classic utilities like awk, sed, find and tar to look after their systems.
Over the years the development of Unix-like systems such as Linux has seen this philosophy diluted with the advent of the bloated bash shell and utilities, although based on the original Unix tools, with ever more complex options.
An alternative I have tried is using Python. Python is a compact programming language, augmented with a large number of modules which extend its capabilities. In this respect Python is similar in philosophy to classic Unix thinking, with the added benefit of being a modern high level and object-oriented language.
In this talk, which will be in a tutorial style, I will describe some of Python's capabilities in a sysadmin context, with code examples, and discuss its benefits. One of the greatest is that Python is multi-platform, being available on Unix, Windows, Linux and Mac. For example it is possible to have one backup script for use across all platforms, and to restore your backups across platforms.
Python Conferencing Systems
Where we've got to with a Conferencing System
John Pinner (Clockwork Software Systems)
Talk, 30 minutes (General)
Nearly every Python conference has had a go at producing a conferencing system. Often these have resulted in a lot of work for the organisers, defeating the object of having a computer-based system.
This year we've set out to produce a simple conferencing system which is easy to use yet helps the organisers rather than hindering them. It will be developed over a one to two year period.
This talk will show where we are and how we got here.
DataFinder: A Python Application for Scientific Data Management
Andreas Schreiber (DLR - German Aerospace Center)
Talk, 30 minutes (General)
The DataFinder is a data management client developed in Python that primarily targets the management of scientific technical data. Data can be attached with individual meta data that is based on a free-definable data model to achieve data structuring and ordering. Moreover, the system is able to handle large amounts of data and can be easily integrated in existing working environments. The system is based upon a client-server-architecture and uses open, stable standards. One of its main features is extensibility using Python scripts.
The server side consists of the meta data server that stores the meta data as well as the system configuration. The server is accessed with the standardised protocol WebDAV by the client side. Data can be stored on the same server as the meta data or separated from it. The concept of separated meta data and data storage allows the flexible usage of heterogeneous storage resources (for example, FTP, GridFTP, operating system data interfaces, or WebDAV).
On the client side, graphical user interfaces for the administration of the whole system (e.g., for configuration of storage resources or meta data modelling) and for the usage of the provided data management functionalities (e.g., storing and retrieving data, searching for data, or executing scripts on data) exist. The user interfaces are implemented in Python and the Qt GUI toolkit (using PyQt). Furthermore, the basic functionality is accessible through a Python-API so that these functionalities can be easily extended or used within other software systems. For example, typical usage scenarios include the automatic migration of existing data archives into the DataFinder-based data storage by provision of specific Python scripts.
The talk is to gives an overview about the basic concepts of the DataFinder and demonstration of typical usage scenarios. Additionally, we want to present our experiences developing such a system using the Python programming language as well as on overview over the used Python modules, for example the Open Source Python WebDAV library developed at DLR. It also presents advantages for using Python in science and engineering, both in research and industry.
ZEORaid - Free, Reliable and Flexible ZODB Storage
ZEORaid turns your (cheap) ZEO servers into a reliable cluster.
Christian Theune (Gocept GmbH & Co. KG)
Talk, 30 minutes (Intermediate)
ZEORaid is a ZODB storage intended to provide a 'no single point of failure' implementation for the ZODB by clustering multiple ZEO servers using RAID techniques.
It is very easy to setup and use and compatible with a wide variety of ZODB versions. It has a rather small and well-factored code base and offers interesting capabilities for future expansion.
The talk will explain and demonstrate the various concepts and capabilities surrounding ZEORaid.
Designing Large-Scale Applications in Python
Concepts for designing large and scalable Python applications that work in practice.
Marc-André Lemburg (eGenix.com Software GmbH)
Talk, one hour (Intermediate)
Python is widely and somewhat inaccurately referred to as a scripting language. While Python is an ideal platform for small scripting tasks, it does in fact cover all the concepts needed for large scale object oriented application development. However, complex applications bring different challenges.
The talk will draw on the speaker's experience with large scale application development using Python as central implementation language and provide a cookbook approach to many of the the problems you face when designing and organizing complex application frameworks.
The approach has been proven in many real-life projects, ranging from web application servers in varying fields of application to complete finance trading systems. Python has always proven to be a truly good choice with an outstanding time-to-market advantage over other implementation languages such as Java or C++. It has literally made the difference for a number of small software development companies competing against multi-million dollar ventures.
Small Team, Big Demands? - Use the Batteries Included
Talk, 30 minutes (Intermediate)
The talk will describe how three foresters were able to convert an impressive requirements list into a working solution for forest management planning using the "Batteries Included" approach of Python. In the adaptable simulation and optimization framework the simulators are composed at runtime by combining model libraries written in C (ctypes) with the XML-based descriptions of the desired computations (xml.etree). After storing the descriptions internally as Python objects (bsddb), the computing utilizes multi-dimensional arrays (numpy) writing results for reporting in a zero-configuration database (sqlite3) as well as generating charts on the fly (matplotlib). Even a small development team benefits from using a software project management system (Trac). The open source framework is available at www.simo-project.org.
Python at Home
How I used Python to Control my Central Heating System
John Pinner (Clockwork Software Systems)
Talk, 45 minutes (General)
When I replaced my old central heating boiler, I wanted to have a modern controller. After considering the commercial alternatives, I decided to use a control PC to give flexibility. I had to write software to manage the system, and guess what, I used Python.
This talk will describe the system, the problems encountered, and the solutions adopted.
SVNChecker - the Missing Link between Version Control and Bug Tracking
The SVNChecker is a hook framework for VCS that integrates into your development environment.
Stefan Pielicke (Information Engineering, University of Applied Sciences Cologne)
Talk, 30 minutes (Beginner)
The SVNChecker is an Open Source framework for pre- and post-commit hooks in a number of version control systems (VCS). It allows tight integration of the VCS into existing development environments and to perform a variety of checks of the committed source code. The major use cases are the integration of VCS with issue and bug tracking systems and the check of source code against coding standards and unit tests.
The SVNChecker is designed and developed as an open extensible framework. By writing appropriate plug-ins it can be extended to almost any kind of "check". This can be used to enforce a variety of regulations of the software development process. By developing "handler" plug-ins the result of checks can be handled in almost all required ways (for example for sending mails, updating databases or running any given external software).
At the moment the SVNChecker is extended with a plug-in technology to allow the integration of any kind of VCS (for example git or Perforce). The programm and its plug-in API is written in pure Python.
This talk starts with a short overview of the process of software engineering and the tools which are typically involved. It describes how version control is used with subversion and how the SVNChecker fits into this to support the checking of source code.
After this general overview the talk will give detailed information about the design of the SVNChecker and will show how it can be extended to fulfil special needs.
Python Language
Duplicate Code Detection using Clone Digger
Talk, 30 minutes (Intermediate)
I'd like to present Clone Digger at the EuroPython conference. It is a tool for finding duplicate code in Python programs, and I'm the author of it. To my knowledge it is the first clone detection tool for the Python language. In my 25-minutes speech I will:
- describe the clone detection problem in general (including Python-specific remarks),
- introduce the theory behind the tool,
- give technical details
- give some examples of Clone Digger usage (including user reviews)
Class Decorators: Radically Simple
Class decorators (new in 3.0 and 2.6) take the black magic out of metaclasses and here's how.
Jack Diederich (Person at Large)
Talk, 30 minutes (Advanced)
Metaclasses have a reputation as black magic; as Tim Peters said "if you aren't sure you need them - you don't need them." The signature is cryptic and metaclasses involve action-at-a-distance. Class decorators can do everything metaclasses do but the signature is simple and they are explicit. Class decorators are just radically simpler and more readable metaclasses.
The talk covers:
- Class decorator signatures
- Metaclass signatures
- Class decorator patterns
- Munge decorator
- Metaclass decorator!
- Brief history
My God, it's Full of Files
Pythonic filesystem abstractions: An overview of different filesystem(-like) APIs in Python and attempts for unifying them.
Talk, 30 minutes (Intermediate)
There's a lot of different filesystem(-like) APIs in Python. I intend to provide an overview of existing projects, their status and capabilities, and hopefully inspire you to work on improving things.
I intend to cover at least:
- sync/async nature of access
- path.py
- - twisted.vfs
- twisted.filepath
- FUSE
- git (including my own project)
- Allmydata Tahoe
- CouchDB
- SFTP, NFS, Plan 9
Cool Stuff with Jython
Showing off some of the things that can be done with Jython
Frank Wierzbicki (Sun Microsystems)
Jim Baker (Zyasoft)
Talk, 45 minutes (Intermediate)
Jython has been improving rapidly in recent times. The current release implements the features of Python 2.2 and the current svn trunk targets Python 2.5 compatibility.
The purpose of this talk is to show off some of the things that can be done with Jython. Python frameworks that now work on Jython, interesting integration with Java frameworks, introspection of Java and more will be demoed.
The target audience is Python developers who wish to learn more about using Jython for various tasks such as using Jython for exploration and integration with existing Java code, using a mix of Java frameworks and Python frameworks, etc.
Potential topics to be covered (I say potential because we might find cooler things between now and EuroPython!):
- Django on Glassfish. Possibly with JMX integration? (So we can observe transactions, other mgmt stats, from a standard JMX console.) Outline how Django will be deployed going forward.
- Help System in Jython including integration with Javadoc.
Integration with Java demo with Swing and cool Java graphics libraries like Alice
- Mapping recursive generators to the Java 7 Fork-Join framework. This is a good demonstration of how Java code can readily call any Jython code that implements a Java interface (or extends a Java class).
Jython Panel
A rare opportunity to connect with the Jython developers
Ted Leung (Sun Microsystems)
Panel, 45 minutes (Intermediate)
Jython has been improving rapidly in recent times. The current release implements the features of Python 2.2 and the current svn trunk targets Python 2.5 compatibility. Since many of the Jython committers plan to be at EuroPython -- we thought it would be a good idea to have a panel. Everyone on the panel is a Jython committer, the moderator Ted Leung is a longtime Python advocate.
Topics that might be covered in the panel:
- Jython status
- How are people using Jython right now
- Where do we see Jython going in the future
Panel:
- Moderator: Ted Leung
- Panel Members: Jim Baker, Oti Humbel?, Tobias Ivarsson, Frank Wierzbicki, possibly other Jython devs that can attend.
Implementing XML languages with lxml
How to make lxml.etree the best data model for your XML-driven application
Stefan Behnel (Senacor Technologies AG)
Tutorial, one hour (Intermediate)
Any XML-driven application needs an internal data representation format. There are two common approaches: you can use the XML DOM tree and adapt your application to it, or you can parse your XML data into some kind of object tree, work with it, and convert it back into an XML tree before you serialise it. Where the first tends to bloat the application source with dedicated code for XML handling, the latter involves writing a converter to move back and forth between different in-memory data representations, and lacks support for handy tools like XPath, XSLT or validation.
lxml is an XML toolkit based on the well-known ElementTree API. It provides features, however, that allow modifying the tree API of lxml.etree in almost any regard, by injecting custom classes into the tree. This makes it possible to use the XML tree as application data structure, but with an API that is well adapted to the needs of the application. Amongst other examples, this feature has been used to implement a Python object API on top of lxml.etree (called lxml.objectify), an HTML API with special support for form handling and links (lxml.html), a library for math term conversion based on MathML, and a graphical editor for distributed systems design.
This tutorial will give a brief introduction to XML handling with lxml.etree, and then present the deeper magic that makes it easy to implement special XML APIs with lxml.etree.
For more information, see the lxml homepage.
The Cython Compiler for C-extensions in Python
Speeding up Python code and integrating with C libraries
Stefan Behnel (Senacor Technologies AG)
Talk, 30 minutes (Intermediate)
Cython is a relatively young project that is based on the well-known Pyrex compiler. While heading to become a general, optimising Python-to-C compiler, Cython provides an extended syntax that makes writing glue code to external C libraries as easy as Python itself. At the time of this writing, the C code generated by Cython compiles on Python 2.3 through 3.0 alpha, which makes it a very helpful tool for writing portable C extensions.
This talk will give a general overview of Cython - the project, the compiler and the language. It will show how fast Cython compiled Python code is and presents recent language improvements during the latest code sprint in June. It may even leave you convinced that Cython is the right language for your next C extension.
For more information, see the Cython home page.
Martian - Declarative Configuration for Python
Embedding configuration information in Python code.
Martijn Faassen (Startifact)
Talk, 30 minutes (Advanced)
Martian is a library that allows the embedding of configuration information in Python code. Martian can then "grok" your code and do the appropriate configuration. Examples are the automatic registration of all "models" in a web application, or the registration of menu entries in a UI application. The traditional way to accomplish this form of automatic configuration involves the use of meta classes. Martian uses a different approach which we believe has benefits.
Martian is used in the Grok web application framework. It is also used by the "grokcore.component" library, a thin layer over the "zope.component" library that helps with component configuration and registration. We will uses these examples to demonstrate some interesting ways to use Martian.
The Inner Workings of Jython
Gaining an insight into how the internals of a Python implementation work
Jim Baker (Zyasoft)
Tobias Ivarsson (Linköping University, Sweden)
Talk, one hour (Intermediate)
This talk will start an overview of the current state of the Jython project with special attention to the features and capabilities of the Jython compiler as we work on finalizing our 2.5 support. Jython compiles Python programs to Java bytecode, but in doing so, must support the dynamic language features of Python.
From there on we continue with a view into the internal workings of Jython by exploring coroutines, a feature that necessarily touches upon a large portion of the internals. The topic of coroutines will start off with its basic building block, generators. This then leads into the associated problems of suspended state and call frame management. We will then go deeper into the subject by considering Stackless and greenlets, and demonstrate how the same capabilities can be achieved with Jython on the JVM.
To make the matter more interesting we will compare the Jython representation to CPython in various aspects. Such comparisons have aided our own development efforts - there is much that the implementations can indeed share, even though they also have their differences due to what can be done on the JVM. In particular, the implementation of greenlets exposes this in a very interesting way.
We hope that the audience will walk away from this session with a greater insight into how the internals of a Python implementation works and also how advanced features like greenlets are implemented.
Dynamic Compilation in Python and Jython
Tobias Ivarsson (Linköping University, Sweden)
Jim Baker (Zyasoft)
Tutorial, Two hours (Advanced)
Treating code as data is a powerful tool that has a venerable history in computer science. Traditionally in Python, the introspection and manipulation of Python code has been through Python bytecode. Usage is incredibly varied:
- template languages, specifically to embed Python or a subset as an expression language
- deferred evaluation, in order to support remoting transparency (OpenDAP)
- tail-call optimization
- object introspection, as seen in inspect.getargspec to determine tuple parameters in a function signature (and to be obsoleted with PEP 3113)
Unfortunately, such usage is tedious, error prone, and not at all compatible across different Python implementations. As of Python 2.5, the _ast module provides an alternative approach, enabling the analysis, creation, and manipulation of Python abstract syntax trees. However, using _ast differs somewhat from Python bytecode manipulation, even if much of the same functionality can be achieved by using either method. To further complicate things other implementations, where Python bytecode is not available, might have their own specific ways of manipulating code. In this tutorial we will try to straighten this out.
We will look in to what you can do with the _ast module and Python bytecode manipulation. We will also look in to what the alternatives are with other Python implementations. Specifically we will look into the alternatives offered by the Jython compiler framework. But we also invite people with insight into Python code manipulation in IronPython and PyPy to participate actively in this session.
The Jython compiler framework provides hooks for extending it with optimisations and other kinds of manipulations, both general for Python and specific to the Java platform. We will throw this into the mix and compare it's features to the abilities of the _ast module and Python bytecode manipulations.
The tutorial will be structured around a few tasks, where we will try on the different tools for each task. This will give insight into how these different tools can be used and when each tool is applicable.
Attendees of the tutorial will learn:
- advanced abstractions to solve interesting problems
- pros and cons of Python bytecode vs AST manipulation
- various tools that are available for various platforms, such as Jython, and what their special capabilities are
Why It's Good To Be Lazy: Functional Programming with Python
Talk, one hour (Intermediate)
When we learn how to program we are told that an algorithm is a sequence of steps to be realized by the computer, leading to an expected result. This imperative approach is the most popular point of view on programming, and the Turing machine is a well-known model for it. But there is another approach, claiming that a program consists purely of stateless evaluations of expressions, where the exact order of evaluation is not defined. This approach is called functional programming, and the lambda calculus defines a mathematical foundation for it. I will speak on what are the benefits of functional programming and how to leverage functional features present in both Python and Ruby.
PyPy for the Rest of Us
A lightweight introduction for people who want to understand the big picture
Talk, 30 minutes (General)
PyPy is a new implementation of Python that has been worked on for about 4 years. It has been usable for a couple of years, but there hasn't been a compelling reason for Python users to use PyPy so far. We expect this to change in the next 6-12 months, so now is the time to find out what PyPy is about, This talk explains the big picture of what PyPy is and isn't, in a way that is accessible to everyone. If you want to understand how a JIT compiler generator works, this talk is not for you. If you want to understand where PyPy stands today and what hurdles remain to make your code go faster, you should attend.
Buildout for Pure Python Project
Carsten Rebbien (COM.lounge)
Talk, 30 minutes (Intermediate)
First Python eggs will be shortly introduced. What problem do they solve, how to install them and where to get them. Then we will explain how you can install and use buildout for making Python development and deployment easier. buildout is mostly used in the Zope/Plone world but is also very useful in other contexts.
ReportLab Paragraphs Reloaded
An alternative approach for paragraph classes to be used with the ReportLab library
Talk, 30 minutes (Intermediate)
ReportLab is a Python library for creating sophisticated PDF documents mainly. It includes a simple document layout engine based on page templates, frame and flowables. Paragraphs play a central role as the most important flowable because they appear in almost every generated document. Over time the implementation of ReportLab paragraphs has accumulated a high degree of complexity. People who want to add functionality to the given paragraph class, like hyphenation, find it very difficult to extend it. This talk presents a new approach for building paragraph classes from scratch that play nicely with the ReportLab library while adding specific functionality as needed. The result at present comprises a family of paragraph flowables that invite people to play with them and extend them with further functionality while remaining sufficiently competitive in performance with the original, but complex, ReportLab implementation.
Accessing File-Specific Attributes on Steroids
A plug-in based tool for accessing file specific attributes and outputting them in a tabular fashion
Talk, 30 minutes (Intermediate)
Fileinfo is a pure Python package for extracting attributes from files and returning them in a tabular overview. Fileinfo is based on plug-ins that allow extracting more interesting attributes than those provided by the operating system (while including these as well). Standard plugins are provided for different file types like PDF, Python, True Type font files and XML documents. They extract attributes like the number of pages and images, author, producer or title (PDF), the number of functions, classes, keywords, imports etc. (Python). The result is written in different formats on the command-line, including, among others, HTML and ReST. Very little work has been done on adding GUIs. This talk describes the design and implementation of fileinfo as well as some weak points and further directions for development.
Visualising Relationships Between Python Objects
A fresh approach in visualising relationships between Python objects uing GraphViz
Talk, 30 minutes (Intermediate)
This talks describes a prototype package that illustrates relationships between objects in Python name spaces. At the moment it is capable of visualising references between Python names and objects and composition of basic Python data structures like tuples, lists and dictionaries. It generates files in the GraphViz DOT format, has a very simple implementation right now and is mostly useful for generating graphs for educational purposes. It is planned, though, to extend it in order to visualise other relationships between Python objects as well, like inheritance and module dependencies.
PyPy Status Talk
Quick summary of cool features of pypy
Maciej Fijalkowski (merlinux GmbH)
Talk, 45 minutes (General)
Quick summary of cool features of pypy, where we are now and where we are going.
abstract: This talk will try to explain to broader public status of the PyPy project, where we are and where we are going. We're going to show some demos of cool features, but also we're going to run real applications on top of PyPy to showcase how compliant our Python interpreter is.
This talk will not cover any internal details (or at least not that many :), which will be covered by different talk.
Writing Python code for different GCs
This talk will pick PyPy's GC as an example and discuss how to write Python code that does not rely on the underlying GC implementation.
Maciej Fijalkowski (merlinux GmbH)
Talk, 30 minutes (Advanced)
Almost all of the newer Python implementations depart from CPython's reference counting as a memory management strategy and use more recent garbage collection strategies. IronPython and Jython use the GCs of the .NET platform and of the JVM respectively, PyPy contains several GCs, among them a moving generational garbage collector. All these GCs have in common that they behave slightly differently than reference counting in some places. Existing Python code often uses patterns that only works well with reference counting.
In this talk we will explain one of the PyPy GCs in detail as an example of the sort of GC techniques that are used. Then we will describe common mistakes that are made and explain ways how to work around them. Specifically we will talk about the different semantics of finalizers and the varying cost of some operations on a moving GC (like id).
Discouraging the Use of Python
Python gets used more and more. The presenter will demonstrate some of the dangers of this development and point out some behaviours which support this trend and how to avoid them
Harald Armin Massa (GHUM Harald Massa)
Talk, 45 minutes (General)
Most statistics show an increasing penetration of the programming market by Python. The dangers are not discussed enough, so this talk will contain some thoughts about it.
Also there are a number of viral strategies to sneak Python into enterprise application development; we will discuss them and learn how to avoid them.
We will learn the most powerful arguments against using Python, their usual counter arguments and how to deal with them.
Why I Want You to Use Eggs
Benefits of using eggs to package your code
Ignas Mikalajūnas (Programmers of Vilnius)
Talk, 30 minutes (Intermediate)
Migrating to eggs as the packaging system for your code is a difficult decision to make when you can't see clear benefits, especially if you are aware that the current state of the egg world is far from perfect.
Psyco - a Step to the Future for Norman
This is some intermediate surrogate while you are waiting for PyPy.
Christian Tismer (tismerysoft GmbH)
Talk, 30 minutes (General)
Psyco is the specialising compiler for Python, that was written by Armin Rigo. It started and was first presented in 2002 at EuroPython and was under active development until September 2005.
At that time it was declared dead and superseded by PyPy, which was expected to be the future of Psyco as soon as 2006. Since then, Psyco was supported by maintenance releases, but not further developed.
Reality had different timings, and people are waiting for a PyPy that is able to give the same performance boosts or better since then.
In order to fill this gap a little bit, Raymond Hettinger and I developed a couple of enhancements to Psyco, as sponsored open source work. We are supporting a number of new built-ins, with special effort given to generator support.
This talk gives an overview of Psyco's technology, its possibilities and limitations, explains the extensions that we did and what to expect in the near future.
After this excursion, I will stop being a renegade and focus on PyPy again.
py.test - Rapid Testing with Minimal Effort
An introduction to writing tests and project-specific customisations and extensions.
Holger Krekel (merlinux GmbH)
Tutorial, one hour (Beginner)
This tutorial talk introduces usage of py.test, a popular tool for writing and running automated tests. We walk through the implementation of tests, layered setup of test state and how to write project specific or global extensions. We discuss the current feature set including extensions for generating HTML pages from test results and distributing test runs from a linux work station to a remote windows machine.
Core Python Containers -- Under the Hood
Look under-the-hood at the implementation of Python's container classes. Understand their performance implications. And walk away with a sound basic understanding of how they work and when to use them.
Raymond D. Hettinger (Self-employed)
Talk, one hour (Intermediate)
Look under-the-hood at the implementation of Python's container classes. Understand their performance implications. And walk away with a sound basic understanding of how they work and when to use them.
The Savoury Flavors of Python 2.6 and 3.0
Learn about the feel of Python 3.0 and how it will change your coding experience.
Raymond D. Hettinger (Self-employed)
Talk, one hour (Intermediate)
Code written for Py3.0 is much the same as that for Py2.5, but it has a different flavor and texture. With the removal of accumulated cruft, the new version of Python feels lighter and cleaner. We discuss what was removed and why. In their place, some new features were added. We discuss how the new tools elegantly overcome issues that have long challenged the language. Besides removals and additions, some aspects of the language were redesigned by changing their underlying concept. Those deep conceptual changes give the language its new flavour. We discuss the new concepts, why they arose, their benefits, and how to alter your world view accordingly. Lastly, we discuss the plan for how to migrate existing code so you can enjoy the benefits of Python's rebirth.
Descriptor Tutorial
Most of Python's advanced features are implemented with descriptors. Learning the descriptor protocol is the key to an advanced understanding of the language.
Raymond D. Hettinger (Self-employed)
Tutorial, 45 minutes (Advanced)
Learn the descriptor protocol, see how it is invoked, examine real examples from the language, and learn to write your own.
Walk away with a sound understanding of methods, properties, super, classmethods, and staticmethods.
Large Scale Python
Using Python in the Amazon Cloud to Analyze your own DNA
Mike Cariaso (BioTeam.net)
Talk, 30 minutes (General)
I've written two applications using Python, which may be of interest to a wider audience. Neither is open source.
The first tool is available from www.runblast.com. It is a Windows desktop application for scientists who want to run a popular but compute intensive analysis method. It relies heavily on the modules boto, paramiko, wxpython and py2exe. The boto library is used to launch a cluster inside the Amazon EC2 cloud. Using the system involves paying money to amazon for the rented machines, but a portion of that bill is a surcharge which is deposited into my bank account. This model is interesting in that piracy is impossible and you pay proportional to how much you use the application.
The second is a tool written in Python called promethease. Promethease is based on pywikipedia and wxpython. It reads a file describing a person's dna, and builds a report. The report is pulled from a wiki database, so users collectively improve the quality of the reports. For a concrete example, see the page Lilly Mendel.
Several companies charge ~$1000 USD for a service where you spit in a tube, mail it to them, and they analyze your DNA. The tool 'Promethease' reads that file, and generates a report like this, but specific to your actual dna.
Managing Computing Clouds on Unreliable Nodes with Python
Gašper Žejn (Zemanta)
Talk, 30 minutes (Intermediate)
Amazon offers web services, that can offer advantage over traditional self-hosting solutions, abstracting away the costs of dealing with hardware failures in a pay-per-use model. However, the nodes can run uninterrupted for months or fail the next day, taking down with it all data that was not backed up. This requires a system for cloud management with support for load balancing and online fail over, with integrated system for boot strapping nodes from bare OS image to running services.
Second Life and the Open Grid Protocol
Christian Scholz (COM.lounge)
Talk, 45 minutes (Intermediate)
I will start with an introduction of what the Open Grid Protocol is and which problems it aims to solve. I will then introduce pyogp which aims to be a Python implementation of the Open Grid Protocol.
The OGP aims to make virtual worlds interoperable. It was initiated by Linden Lab, makers of Second Life and the protocol will be developed with the community and submitted to standards bodies. pyogp will hopefully be a joint effort between the community and Linden Lab. Second Life will be migrated to the new architecture step by step.In the end the result is a structure more fitting the internet where servers can be put up elsewhere and connect to existing grids
pyogp can be found at code.google.com/p/pysecondlife.
FlowSimulator
A Python-controlled framework to unify massive parallel, multi-discipline CFD workflows
Talk, 30 minutes (Intermediate)
Over the last years, multi-disciplinary simulations got more and more important. Especially, in the field of aerospace science and engineering, the aim is to 'fly the virtual aircraft', i.e. to gather as much information about future aircraft as possible before their first flight, including aerodynamics and aero elastics as well as economic data (e.g. the range of new aircraft). The underlying simulations incorporate tools from different vendors and research facilities which have to be coupled. Right now, this is often done by simple shell scripts, user interaction and a lot of disk I/O and copying across the network which slows down the complete process.
To overcome this, the FlowSimulator framework has been developed by Airbus, DLR; EADS, and others as a new backbone for scientific computations in the field for aerodynamics and associated topics. It consists of the FlowSimulator DataManager (FSDM) which is a library providing fully-parallelized data structures for numeric simulations. This library can be extended using a (pseudo-)plug-in mechanism and is largely interfaced to Python.
On top of this, there is the FlowSimulator Control layer. This is a pure Python library helping the user to define work flows in an easy way. With this library, the whole scientific and industrial simulation process can then be controlled and monitored by a Python script.
The talk starts with some motivational background about large multi-disciplinary aerospace simulations in science (DLR) and the aerospace industry (Airbus and EADS). It describes the basic concepts of the FlowSimulator framework with focus on the Data Manager and Control Layer. The talk with show, how Python is being used and describes the advantages and drawbacks for using Python in massive parallel applications. Also, Python example scripts are being presented, which demonstrates their ease of use for solving complex simulation tasks.
User Interfaces
Python, Windows, Bazaar
Mark Hammond talks about the technical challenges, and roadmap, for integrating the Bazaar version control system into Windows, using Python.
Mark Hammond (Canonical)
Talk, 30 minutes (Intermediate)
Mark will talk about his roadmap for Python-based version control on Windows, and the technical challenges of integrating a Python application and library into Windows.
Web Programming
Advanced Searching for Plone: XML integration with Google CSE
Google CSE's business edition has an XML API. This has been used to integrate Google CSE with Plone.
Jan Murre (Pareto)
Talk, 45 minutes (Intermediate)
Google has a service called Custom Search Engine. The business edition of this service has an XML API. This API has been leveraged to integrate Google Search into a Plone site.
Using Python (batteries included) this is surprisingly easy.
First there will be a brief introduction on Google CSE. After that, the use of the XML API from Python code will be demonstrated. Then the integration in the Plone CMS will be explained.
Spring into Pylons (the widgets.opera.com story)
The widgets.opera.com story
Jonathan Share (Opera Software)
Talk, 45 minutes (Intermediate)
Towards the end of the summer of 2007 2 primarily JavaEE developers took over the Perl based widgets.opera.com site and transformed it into a Pylons application. Attending this presentation you will learn how our Java experience influenced the code architecture, learn some tips for handling common tasks and the problems we have experienced along the way.
Capistrano, for Painless Pylons Deployment
Jonathan Share (Opera Software)
Talk, 30 minutes (Intermediate)
Capistrano is a tool that has served the Ruby on Rails community well for automating application deployment. In this presentation you will learn the features provided by Capistrano and how they can be put to use for deploying Pylons web applications.
Dr Strangelove - or how I came to love Zope 3
Introduction to migrating content management systems towards from Zope 2 to Zope 3 and gaining enlightenment
Charlie Clark (Clark Consulting & Research)
Tutorial, 45 minutes (Intermediate)
Like many web developers who don't necessarily come from a programming background I've been using essentially the same framework and same technique for years: it's tried and tested and I get usually get it to do what I want. My framework happens to be Zope 2 and while I love it I know it has limitations but, and this is a big but, it is often difficult to get customers to pay you to redo their site, which they're perfectly happy with, using the latest and greatest especially as this means paying you to learn as you do it. So while, I've followed Zope 3 from it's beginnings and appreciate much of the improvements I haven't been able make the change myself. In the meantime a whole new generation of frameworks and with it developers inspired by Ruby on Rails has grown up and while these frameworks have their place and their advantages, they are definitely not for me.
Recently, however, I have been working on projects where the traditional Zope 2 approach isn't entirely suitable. Fortunately using Zope stuff, for want of a better word, with Zope 2 provides extremely usable solutions at the same time as providing a real understanding of modern programming principles as applied to web development and this is the real benefit and what I would like to try and share. Much programming is often simply fashion driven as much by acronyms as intelligence (SoS, cloud, Web 2.0) with as much thought given to programmer gratification as to meeting customer requirements. As a result a great many websites are at best little more than add-ons to customers businesses.
Zope 3 is different because it emphasises the what and the why far more than the how. Anyone who develops a Zope 3 website will have an appreciation for component-based development and an understanding of application development that goes beyond the essentially procedural paradigm that unfortunately still largely dominates web development. It is undoubtedly a challenge to adopt the Zope 3 approach but one that is well worth taking and the talk will attempt to point out the benefits to be gained by adopting it.
A New Approach to Web Authoring on Zope
Talk, 45 minutes (Intermediate)
Most users looking to build a website have a need to author and present content, not to manage it; ironically, most solutions that claim to provide content management aren't very well suited for it. They are instead used for authoring and presentation, but still carry the weight of a content management system.
Vudo is a free open-source web framework built on top of Zope 3 that tries to fill this void. With lessons learned from existing frameworks, we've taken a radically different approach to content, presentation and storage. Content is simple, presentation is easy and storage is delegated to SQLAlchemy. And it's fast.
In this talk I'll demonstrate how to take a random HTML mockup and bring it to life as a brand-new web site running on Vudo with enough time left to answer questions.
Data Portability and Python
Christian Scholz (COM.lounge)
Talk, 45 minutes (Intermediate)
I will give an introduction what Data Portability is and what the DataPortability Project is about. I will then demonstrate the pydataportability library which aims to implement the best practices and standards for making data more portable (such as microformats, FOAF, XRDS etc.)
pydataportability can be found at code.google.com/p/pydataportability
The DataPortability Project can be found at dataportability.org.
Grok for Your Next Web Application
Martijn Faassen (Startifact)
Talk, 30 minutes (Intermediate)
Grok is a web application framework. It aims to expose the power of Zope 3 in a more convenient way, but requires no knowledge about Zope. It aims to be an agile framework without the loss of power and flexibility. The talk introduces Grok, the aims of the Grok project, and Grok's strengths and features. The talk aims to explain to developers why Grok is a serious contender in the Python web framework space, and why they should consider using it in their next project.
Django's Newforms Admin
Talk, 30 minutes (Intermediate)
Django's newforms admin branch is nearing completion, I want to give a brief overview of what's new, what's changed, and where it's headed. I can demonstrate new features of the application using real world examples (both dos and dont's).
Structure of the talk:
- introduction to Django and its admin
- old admin and its problems
- newforms library in django
- changed syntax (what you need to change to move to nfa)
ModelAdmin class (how it works, what can you do with it)
AdminSite (dtto)
- Misc (edit_inlines, custom widgets, forms, formsets, ...)
- The future - model-aware validation (#6845), class based admin views, .......
Q&A
Math on Web Pages and Mixed Language Programming
Talk, 45 minutes (Intermediate)
Since summer 2007, the MathTran server (www.mathtran.org, mathtran.wordpress.com) provides rendering of TeX-notation mathematics as a public web service. It is now serving about 48,000 images a day. The MathTran server is written mostly in Python, with UK financial support from JISC and the Open University.
The MathTran project is now moving on to the effective display and authoring of mathematics on web pages. A key component to this is the creation of suitable JavaScript libraries, to which Christoph Hafemeister is contributing as part of the 2008 Google Summer of Code.
The project would like to develop or obtain a parser for the TeX language that works both on JavaScript and Python, and which gives identical results in both. This is so TeX can be validated both on the browser and the server, as is convenient. This problem is of broader interest. For example, both Pygments and Chili are generic syntax highlighters.
As Ajax and Comet become more widespread, so tools that generate effectively identical HTML on both server (Python) and browser (JavaScript) will become more valuable.
This talk will:
Give an introduction to the MathTran server
Describe how to write simple MathTran clients
Describe the MathTran JavaScript libraries
- Discuss the cross-language parsing problem
Build an App in a Week
Tips, tricks and good practices for building complete web applications really fast.
Tutorial, one hour (Intermediate)
I would like to talk about the results of my experiments in building complete websites really fast: from an idea to fully functional website in a week or two, with the right tools and practices.
Unlike all the "build a blog in 20/30/60 minutes" presentations, this one is based on building real, useful applications for people other than the author.
The plan:
- general rules
- look for existing libraries first, write new code only when having no other choice (code is a liability)
- don't go crazy on reusing your own code
- DO write it in a way that will make it easy whenever it is free/cheap
- DO NOT set off to create generic libraries that will solve more problems than you are going to encounter
- Django, newforms-admin
- really short introduction for the people who don't use Django, just slides, without live coding
- startproject
- startapp
- 2-3 simple models
- switch on the admin module for them
- voila, you have a fully-functional editor and administrative interface
- give your end users access to the admin interface
- this will save you somewhere between 20% and 50% of the code (and thus, time), depending on the project
- you can customize it a lot
- the looks: CSS and template tweaks
- the behaviour: create new views using new capabilities in the newforms-admin branch
- all this without changing the Django source code
- deseb for schema evolution <