Europython 2006

3 Jul 2006, 08:00 → 5 Jul 2006, 18:00 Europe/Zurich

CERN, Geneva

REGISTRATION

NETWORK

TRAVEL

PASSPORT & VISA

ACCOMMODATION

SOCIAL EVENTS

ON-SITE INFORMATION

REGISTRATION Complete the registration form to register for the Conference, conference diner, accomodation and CERN visit : Registration form. Registration will take place at the main reception in Building 33 on Monday, July 3rd from 8:00 am until 9:00 am. For people arriving at CERN on the weekend or outside office hours (after 18:00) on Friday, the registration is handled by the guards at the main entrance (entrance B).

NETWORK PRIOR your arrival at CERN, participants are strongly encouraged to request to allow access to the CERN network. Registration of portables is mandatory. Complete the network connection request form. ONLY registered computers will get network access : step-by-step instructions. Wireless network is available in most conference rooms, in the Library and also in the hostel (building 39 only). European-Swiss adaptors are needed to adapt to a Swiss power sockets (three pin).

TRAVEL How to get to CERN ? Airlines Easyjet|Virgin|Low cost flights to Geneva|Geneva Airlines|Geneva International Airport Swiss International Airlines Railways Europe|Switzerland|France|Eurostar|UK|Italy|Hungary|Slovakia Transport Public Genevois Buses run in Geneva from 6:00 am until midnight, outside these hours call a taxi at 022 320 22 02. Bus itinaries & timetables CERN : line Y | line 9.

PASSPORT & VISA For citizens NOT belonging to the European Economic Community, it is strongly recommended that you enquire at the relevant consulate to find out the conditions of admission applicable to you in Switzerland and/or in France. You are kindly asked to take the necessary steps to obtain the papers required for Switzerland and/or France, make your passport and visa application at the Swiss and/or French consulate corresponding to your usual place of residence. Entry into Switzerland|Entry into France

ACCOMMODATION Participants are required to arrange their own accomodation. To offer further help in your search for rooms, some useful links are indicated hereafter : CERN Hostel|Hotels with special rates|Geneva Tourism. The CERN Hostel Reception is located in building 38-39 and is open between Monday and Friday from 7:30 am until 7:30 pm and Saturday-Sunday from 9:00 am until 1:00 pm. Outside the opening hours, roomkeys are available at the main entrance B (ask the guard). Hotel booking in Geneva - Service free of charge : + 41 (0)22-9097020 Reservation@geneve-tourisme.ch

SOCIAL EVENTS A CERN Visit will be organized on Thursday, July 6th, 2006 from 9am until approximately 12am. The programme includes a conference introduction for about 30 minutes, the projection of a short film for about 20 minutes and a CERN visit for about two hours. Do not forget to carry your passport with you, and your visa if need be, because the visit itinerairies can be either in France or in Switzerland. Photographs and video cameras are allowed. As the limited number of places is 100 and the visit is free of charge, places will be allocated on a first come basis. If you are interested, please select the CERN visit in the registration form. The conference dinner will take place in the CERN restaurant in building 500 on Tuesday, July 4th, 2006 from 8.30pm until 11pm. If you are interested, please select the conference dinner in the registration form.

ON-SITE INFORMATION CERN map|CERN buildings Breakfast, lunch and dinner : a self-service restaurant is located in Building 500 and is open between Monday and Friday from 7:00 am until 01:00 pm and between Saturday and Sunday from 7:00 am until 11:00 pm. The price range for a meal (starter+menu+dessert+drink) is between 15 and 17 CHF per person. The restaurant accepts Euros in notes only. Post Office Meyrin is located in Building 63 and is open from 8:30 to 13:00 and 13:45 to 16:30. UBS Bank Office is located in Building 500 and open between Monday and Friday from 8:30 am until 4:30 pm. Swiss Franc and Euro cash dispensers with a very wide credit card range are also placed near the bank.

CERN PH-SFT| Queries about Europython 2006 | Last modified 16 January, 2006

Conference Agenda Agenda

Monday, 3 July

08:00 → 09:00 Registration: Building 33

09:00 → 10:40 Agile Development

09:00 Ajax, state of the art

Ajax has played an important role over the last months on improving the user experience over web interfaces. Besides all the buzz around Ajax and Web 2.0 related technologies, numerous Javascript libraries have started to consolidate some coding patterns and to provide usable features. This presentation is a state of the art of Ajax related technology, and presents what web developers can benefit from it, with considerations about accessibility (WAI) and ergonomics matters, but also with a focus on Javascript TDD (Test Driven Development) and continuous integration in a Python environment. Last but not least, the presentation will focus on Ajax uses cases for ECM (Entreprise Content Managment) and CMS (Content Managment System) systems, and implementations examples, taken from Nuxeo CPS. References: http://blogs.nuxeo.com/sections/blogs/tarek_ziade/archive_view?category=AJAX http://cps-project.org

Speaker: Mr Tarek Ziadé (Nuxeo)

Slides ajax.odp ajax.pdf

09:35 Testing web applications with HyperTest

As web applications grow increasingly complex, and the logic of those applications is located on the client more often, the need for good JavaScript testing tools is growing. There are some products available, but the quality is usually not satisfactory: most tools are inflexible, messy, hard to integrate, badly written or incomplete. HyperTest tries to solve those issues. HyperTest is a set of JavaScript libraries that allows testing all aspects of a web application: there's a unit test library to test JavaScript APIs, a functional testing library for user interfaces and a library for testing REST APIs by sending HTTP requests and examining the response. All the tests are written in plain JavaScript and run inside browsers, allowing testers to use the full power of JavaScript and test the problem areas, like browser differences and JS implementation quirks. In addition to the JS libraries there is Python code available that allows automating browser control and makes the results from browsers available to the outside. This makes that HyperTest can easily be integrated into Python test suites; full py.test integration should be available in the near future. Using HyperTest one doesn't need to visit web pages as part of the test cycle anymore: results appear together with 'normal' Python test results. I will be discussing common web application testing problems and provide examples of how to deal with them using HyperTest.

Speaker: Mr Guido Wesdorp (Merlinux)

Slides hypertest-ep2006.tar.gz

10:10 Introduction to pywinauto

To be able to automate GUI testing you first need to be able to automate the GUI. The idea is to operate the GUI much as the user would, and test that the software reacts as expected. Many GUI automation tools require you to record details of the application first - or require you to directly specify the control title to work with. These can be very brittle in the face of software changes. Most commercial tools have their own language - which isn't Python! Pywinauto uses attribute/item access with fuzzy matching to specify controls which could be less brittle then exact matches. It also leaves open the possibility of having localization testing done much more easily then with standard tools. This talk will give a quick introduction to using pywinauto and then show the basics of how its internals work.

Speaker: Mr Mark Mc Mahon (.)

Slides EuroPython_gva_3_july.zip

09:00 → 10:40 Python Language and Libraries

09:00 Introducing PyQt4 for GUI Application Development

PyQt4 is a set of bindings for Qt 4, a cross-platform C++ framework used to make graphical user interface (GUI) applications. With the release of PyQt4, Python developers are now able to develop powerful cross-platform applications and deploy them under the GNU General Public License (GPL) or the Qt Commercial License on all platforms that support Qt and Python. We will first briefly discuss PyQt (for Qt 3) and PyKDE (bindings for the K Desktop Environment), and take a look at what has changed in PyQt4. The main part of the presentation will cover the new possibilities that PyQt4 offers developers, including access to Qt's rich text handling features, sophisticated data handling controls, internationalization support, and integration with the Qt Designer GUI design tool.

Speaker: Dr David Boddie (Trolltech AS)

Examples http://www.python.org/pypi/EuroPython2006_PyQt4_Examples/

Slides Introducing_PyQt4_for_GUI_Application_Development.pdf

09:35 Integrating Twisted With Existing Applications

Twisted is an event-based framework, with many high-level constructs for handling networking, threads and more. Unfortunately, existing applications are often written so as to own a whole thread of execution. This talk will survey various techniques, using an arranged hypothetical case study, for integrating Twisted with already-existing applications.

Speaker: Mr Moshe Zadka (B-hive Networks)

Slides integrating-twisted.html

09:00 → 09:30 Refereed Papers

09:00 The Python interpreter as a framework for integrating scientific computing software-components

The focus of the Molecular Simulation Laboratory is to model molecular interactions. In particular we are working on automated docking and molecular visualization. Building and simulating complex molecular systems requires the tight interoperation of a variety of software tools originating from various scientific disciplines. Over the last 10 years we have evolved a strategy for addressing this formidable software engineering problem by developing and integrating software components using the Python language and its interpreter. The basic idea is that the Python interpreter serves as the integration framework and provides a powerful and flexible glue for rapidly compositing components (i.e. Python packages) into applications. We no longer think in terms of programs, but rather in terms of packages, which can be loaded dynamically when needed, and instantly extend our framework (i.e. the Python interpreter) with new capability. We have written more than 25 packages (>1500 classes) providing functionality ranging from scientific visualization and visual programming to molecular simulations. Applications created from these components have been distributed to over 15000 users around the world. In this paper we will describe our approach and various applications, discuss the reasons that make this approach so successful, and present lessons learns and pitfalls to avoid in order to maximize the reusability and interoperability of software components.

Speaker: Prof. Michel Sanner (The Scripps Research Institute)

Paper MichaelSanner.pdf

Slides EuroPythonSanner1.pdf

09:00 → 10:40 Web Frameworks

09:00 Working Together on the Web

Python's web ecosystem is richer than ever. For every part of the web application stack, there are more choices than ever, and there are more full-stack web frameworks than ever. Every application has different requirements, which makes choice useful. In my talk, I will discuss how the Python web landscape has been changing and how it's possible to have choices and still avoid reinventing wheels and dividing up our efforts.

Speaker: Mr Kevin Dangoor (Blazing Things)

10:10 Developing Applications with the Web Server Gateway Interface

The Web Server Gateway Interface is a standard interface between web servers and Python web applications or frameworks, to promote web application portability across a variety of web servers. Although the specification has been around since 2003 there is still a broad lack of understanding in the Python web community about the WSGI and why it is so useful. This hands-on talk will give people new to PEP 333 all the skills they need to start writing their own WSGI applications along with a knowledge of current best practice and a brief overview of the WSGI components that are already available in projects like Paste (www.pythonpaste.org).

Speaker: Mr James Gardner (3aims.com)

Slides WSGI_final.pdf

09:35 → 10:40 Python in Science

09:35 The Enthought Tool Suite for Scientific Applications

The Enthought tool suite (ETS) is a collection of packages for developing scientific applications. It includes a variety of tools ranging from Envisage, a framework for building scriptable and extensible applications, to Mayavi, a general 3D visualization package. This talk provides an overview of the collection's capabilities and demonstrates their use in a variety of applications. Here is a quick description of the several packages we will cover: Traits ------ Traits forms the foundation of almost every other package in ETS. It allows developers to specify type information for Python class members. This information is used for intializing and validating these members as well as building user interfaces for an object via Traits UI. Additionally, traits supports an observer pattern where "listener" methods are called whenever a member trait changes. Kiva ---- Kiva is a platform independent vector based drawing library for rendering 2D graphics. It is path and affine transform based, and supports alpha transparency. Kiva is used extensively by both the enable and the chaco libraries. Enable ------ Chaco ----- Chaco is Enthought's package for building interactive 2D plots. It architected to support customizable interaction with scientific data as well as efficient rendering of large data sets. Tvtk ---- Tvtk is a "traitsified" layer on the VTK visualiztion library. In addition to the facitlities provided by traits, tvtk provides a more convenient interface as well as more efficient sharing of data between VTK and Python Numeric/NumPy data structures. Mayavi ------ Mayavi is a general purpose 3D visualizaiton plugin for Envisage applications developed by Prabhu Ramachandran. This tool is actually 3nd generation of the original Tk based Mayavi application. Mayavi is built on top of Tvtk. Envisage -------- Envisage is a plugin based architecture for developing scriptable and extensible applications. There are a number of plugins that come with ETS including a text editor, python shell, mayavi, and others that can be combined together along with domain specific plugins to develop full features applications. More information on ETS is available at http://code.enthought.com/ets.

Speaker: Dr eric jones (Enthought, Inc.)

10:10 Envisage - An Extensible Application Framework

The Java world has two dominant frameworks for extensible application development: NetBeans and Eclipse. Although many people think of these two projects as IDEs, they are both built upon open architectures that are designed to support generic GUI application development. Treading lightly in the footsteps of these two excellent projects, Envisage attempts to bring similar capabilities to the Python community. The heart of Envisage is its plug-in architecture; in fact, the Envisage core is little more than a system for discovering, loading, starting and stopping plug-ins. Developers construct applications by choosing from the set of supplied plug-ins (possibly the empty set) and then adding their own to provide domain-specific functionality. Although an Envisage application need not have a GUI, Envisage comes with an ever-expanding set of plug-ins that simplify many of the more common and tedious aspects of GUI development (e.g., window management, menubars/toolbars, user preferences). It is worth noting that these 'standard' plug-ins are written in exactly the same way as those written by an application developer. Each plug-in uses the Envisage extension mechanism not only to contribute to what came before it, but also to define how future plug-ins can contribute to it. This mechanism is simple but consistent, and ensures that even extensions to an application are extensible. This presentation will introduce the Envisage plug-in architecture, and demonstrate how applications both with and without GUIs can be built with it.

Speaker: Mr Martin Chilvers (Enthought Inc)

Slides euro-python-2006.odp

10:40 → 11:00 Coffee Break

11:00 → 12:40 Agile Development

11:00 Literate testing with doctests

Doctests are one way of writing automated tests in Python. Doctests can be used for many purposes. I will demonstrate (with examples) the use of doctests for documentation, design, unit testing, and functional/acceptance testing. I will show some interesting features of the doctest module such as pattern matching or diffing. I will show how to collect and aggregate doctests into unittest-compatible test suites. I will talk about certain caveats and demonstrate some useful techniques for writing the tests themselves. About the author: Marius has been writing Python code for the last 4.5 years non-stop. He is deeply convinced about the gains of automated tests, and thinks that if you do not already write doctests for your Python code, then you should start doing so.

Speaker: Mr Marius Gedminas (Programmers of Vilnius)

Slides literate-doctesting.pdf

11:35 zope-cookbook.org, an open Zope book based on agile documentation principles

zope-cookbook.org is an open book project that contains recipes and tutorials for Zope 3 developers. This book is written in several languages (French and English so far) and based on agile documentation principles. It uses Python doctests to provide participants the ability to write their recipes like they would write code, by using a test-driven approach. The code examples can therefore reach a high level of quality, since they are executed for real, and evolves with the framework in use. After a brief technical overview on how the project runs, and some extracts, the presentation will explain how a book project can be driven exactly like a software one, and why it is very important in such a dynamic and moving project like Zope 3. EuroPython would be a nice place to promote the project to the Zope and Python community, to get direct feedback and even maybe new writers!

Speaker: Mr Tarek Ziadé (Personal project)

Slides zope-cookbook.odp zope-cookbook.pdf

12:10 Planning your tests with morphological analysis

Morphological analysis is a powerful approach to generic problem solving. Using this method you can reliably plan for the minimal amount of test cases you should cover for your application. This talk will demonstrate how to apply the methodology and how to manage test plans with a test planning software based on morphological analysis.

Speaker: Mr Christian Theune (gocept gmbh & co. kg)

Slides Europython-Testplanning.pdf

11:00 → 12:40 Python Language and Libraries

11:00 Python and PostgreSQL - a match made in heaven

PostgreSQL is a heavenly match to Python. Both share the same kind of licence, both have an excellent community, both work perfectly together. I will destroy bad PostgreSQL myths, give an overview of using PostgreSQL to interface with Python, and as a special feature show how to use Python inside PostgreSQL to write stored procedures. The business aspect, the possibilites of rollout and also the availability on the main plattforms will be discussed.

Speaker: Mr Harald Armin Massa (Na Zen Baer)

11:35 Index & Search: itools.catalog

There are not many solutions for indexing and searching in Python. Among them itools.catalog is the only one 100% Python and actively maintained. This talk will explain the usage of itools.catalog. We will also define its functional scope, this is to say, what it can do and what it cannot do. And we will put it in context with other solutions available to Python.

Speaker: Mr Luis Belmar-Letelier (Itaapy)

12:10 Using CSV as an indexed persistent layer

This talk will introduce how itools.csv provides a high-level API to handle CSV files. From the loading of a simple CSV file to the serialisation of a complex object, we will demonstrate automatic type marshalling, rows handling, and the search engine. We will address underlying concepts, such as datatypes encoding and decoding, indexing, and querying by using a simple syntax. Extending the API will also be illustrated. Change your point of view on CSV!

Speakers: Mr Hervé Cauwelier (Itaapy), Mr Nicolas Deram (Itaapy)

Slides CSV.pdf

11:00 → 12:40 Python in Science

11:00 Introduction to Code_Aster

Code_Aster is a simulation tool for mechanics developed over the past twenty years at Electricité de France Research and Development. In the year 2000, its home-brewed scripting language was replaced with Python. This talk will present the features of Code_Aster and the benefits gained by the use of Python.

Speaker: Mr ludovic aubry (logilab)

11:35 OpenAlea - A platform for plant modelling, analysis and simulation

The aim of the plant architecture research community is to understand the biological processes involved in the function and growth of plants with explicit representation of their topology and geometry. To understand these systems, which may be quite complex, researchers in botany, ecophysiology, forestry, horticulture, applied mathematics and computer science share experimental data, plant models and software tools. Research in this domain concerns several different scales, such as plant cells, plant organs, entire plants and plant populations. To support this research, we are developing OpenAlea, an open source software platform implemented in Python. OpenAlea is used for the integration and comparison of diverse models and tools provided by the research community. We use Python to glue together components implemented in various languages (e.g. C, C++ and Fortran). Standard wrapping tools, such as Boost.Python, Swig and f2py, are used to support the integration process. Different components can use common data structures such as sequences, tree graphs and multiscale tree graphs. To ease the communication between components, a unique interface has been specified for each data structure. The Zope component framework is used to define interfaces and adapters. Three types of components are integrated into OpenAlea: - analysis of plant architecture (e.g. AMAPmod), - geometric representation and visualization of plants at different scales (e.g. PlantGL), - and simulation models of ecophysiological processes (e.g. RATP, Archimede, PyCaribu, etc.). Users can combine components from OpenAlea and other Python scientific libraries into customised work flows according to their specific needs. Training courses on Python and OpenAlea's modules are given in France and other countries (e.g. Thailand, Brazil, etc.) or through an e-learning platform.

Speaker: Mr Christophe Pradal (CIRAD)

Slides OpenAlea_EuroPython.pdf

12:10 Factory monitoring with Pylons, XML-RPC and SVG

I write Python applications for a company specialising in industrial factory monitoring and scheduling. Most recently we have developed a web application for remote monitoring, sending text message alarms when machine hoppers run low. We're using the Pylons web framework, Myghty templating, XML-RPC and SimPy simulation. The dynamic graphical display of the factory is written in SVG, for Firefox (v1.5) web browser. We will look at interesting issues such as * the choice of framework and templating system, * the importance of decoupling threads using a log file and XML-RPC, * historical correction of data, * and why we needed simulation.

Speaker: Dr Rob Collins (Europython 2006 Conference)

11:00 → 12:40 Web Frameworks

11:00 The Django Web Framework

Django is a Python web framework designed to enable "web development with journalism deadlines". This talk will provide an overview of the framework, discuss the environment in which it was developed and describe the evolution of the framework in the year since it was first released.

Speaker: Mr Simon Willison (Django)

Slides the-django-web-framework.pdf

11:35 MoinMoin Wiki Development

MoinMoin is a popular and powerful wiki engine in Python. The talk will give an introduction to the MoinMoin core source code, extension concepts and extension development. Shortly, we will present the flexibility of MoinMoin and how the user base (Python, Apache, Ubuntu, ...) looks like. We will give an architecture overview as well as explain some code and show how you can write your own.

Speakers: Mr Alexander Schremmer (MoinMoin Wiki Core Team), Mr Thomas Waldmann (MoinMoin Wiki Core Team)

Minutes http://moinmoin.wikiwikiweb.de/EuroPython2006/CoderTalk

Slides http://moinmoin.wikiwikiweb.de/EuroPython2006/SlideShow

12:10 Generating content types and workflow with ArchGenXML

For many people, ArchGenXML is the most attractive way to get started with Plone development. Generating your content types from a UML class diagram is easy and fast, especially as ArchGenXML sets up all the "bookkeeping code" for you: the __init__, the Install.py, etc. The presentation will cover this and I'll also show how to modify the generated code to your special needs. ArchGenXML is great at generating a complete workflow out of UML state diagrams. You get good code that hardly ever needs modification from a UML diagram that you can readily show to your customer - and he'll be able to understand it (mostly). I'll show how to do this in the presentation. Depending on the improvements made on ArchGenXML I hope to show our support for zope3 goodies in plone 2.5.

Speaker: Mr Reinout van Rees (Zest software)

Slides europython2006.pdf

12:40 → 14:00 Lunch

14:00 → 15:40 Agile Development

14:00 eXtremeManagement of projects with Plone

eXtremeManagement is a Plone product that helps in developing using the Extreme Programming methodology. It helps steer a project to success by a focus on planning, on estimating and on keeping a log of your hours worked. My colleagues and clients at Zest Software like it. Goals of the talk: - Get a feel for the planning and estimating parts of XP. - Demonstrate the eXtremeManagement product and show how it helps with this. - Get improvement ideas for eXtremeManagement and probably for your own project management software.

Speaker: Mr Maurits van Rees (Europython, Zest Software)

Slides http://zestsoftware.nl/Members/maurits/xmtalk

14:35 Distributed Source Code Management tools

A new breed of Source Code Management tools has exploded in the Free Software world. These are the Distributed SCMs, an indispensable tool for the agile developer. This talk will explain how a Distributed SCM is different from a Centralized one, and why this makes a special difference in an agile environment. We will expose our working experience at Itaapy with these tools: - how they became the central part of our production process. - what was the motivation to move from CVS to GNU Arch, and then from GNU Arch to Git and Cogito. We will close with a tour through the most prominent solutions available: Bazaar-NG, Darcs, GIT and Mercurial. And we will explain why we chose GIT.

Speakers: Mr Hervé Cauwelier (itaapy), Mr Luis Belmar-Letelier (Itaapy)

Slides DSC_management.pdf

15:10 Source code management for a distributed team.

One way to manage the source code flow for medium size projects with distributed teams. Canonical manages the source code for its Launchpad project using bzr. Launchpad has 15 developers spread over 5 continents who primarily work from home. We demonstrate how a feature goes from being just an idea through development, code review and finally being committed to the official source code tree after it passes our regression test suite.

Speakers: Mr Robert Collins (Canonical Limited), Mr Steve Alexander (Canonical Limited)

Slides EP2006-SCMFADT.odp

14:00 → 15:40 Python Language and Libraries

14:00 Programming Avalon with IronPython

This talk will use a simple (but useful) example application to demonstrate how Windows Presentation Foundation (WPF) applications can be build using Python. The talk will begin by explaining key Microsoft .NET concepts and how they can be accessed though IronPython. Authoring simple eXtensible Application Markup Language (XAML) interfaces will also be demonstrated, both using Microsoft's GUI tools and by writting XAML code directly. Finally, the key points in building and packaging a complete WPF application will be illustrated.

Speaker: Mr Brian Quinlan (Scionics)

Slides avalon.zip

14:35 Design by Contract in Python: Present and Future

Design by Contract (DbC), as proposed by Bertrand Meyer, is an approach to software development whereby the expectations (preconditions) and guarantees (postconditions and class invariants) of methods are formally specified. These formally-specified contracts can then be checked automatically at runtime. First, Design by Contract as proposed by Meyer is defined, its strengths and limitations are described, and the rationale behind the various aspects of the definition are explained. Second, several implementations of DbC for Python, each taking a different approach, are introduced. The implementations are compared to one another and to Meyer's proposal, with particular attention to their suitability for production use. (At least one implementation will be demonstrated live.) Third, attributes desired of a future production-quality DbC system for Python are outlined, and possible evoltionary paths based on existing implementations are proposed.

Speaker: Mr Aaron Bingham (Cenix BioScience GmbH)

Slides presentation.odp presentation.pdf

14:00 → 15:40 Python in Science

14:00 MDP 2.0 - A data processing framework for scientific development and education

We present release 2.0 of the Modular toolkit for Data Processing (MDP), a data processing framework written in Python and based on numpy (the most popular numerical extensions to Python). From the user's perspective, MDP consists of a collection of trainable algorithms or other data processing units (nodes) that can be combined into data processing flows. Given a sequence of input data, MDP takes care of successively training or executing all nodes in the flow. This structure allows to specify complex algorithms as a sequence of simpler data processing steps in a natural way. Training can be performed using small chunks of input data, so that the use of very large data sets becomes possible while reducing the memory requirements. Memory usage can also be minimized by defining the internals of the nodes to be single precision. From the developer's perspective, MDP is a framework to make the implementation of algorithms easier. The basic class 'Node' takes care of tedious tasks like type and dimension checking, leaving the developer free to concentrate on the implementation of the training and execution phases. The node then automatically integrates with the rest of the library and can be used in a flow together with other nodes. MDP 2.0 introduces some important structural changes. It is now possible to implement nodes with multiple training phases and even nodes with an undetermined number of phases. This allows for example the implementation of algorithms that need to collect some statistics on the whole input before proceeding with the actual training, or others that need to iterate over a training phase until a convergence criterion is satisfied. The ability to train each phase using chunks of input data is maintained if the chunks are generated with iterators. Moreover, it is now possible to define nodes that require supervised training in a very straightforward way by passing additional arguments (e.g., labels or a target output) to the 'train' method. Moreover, new algorithms have been added, expanding the base of readily available basic data processing elements. Currently implemented algorithms include Principal Component Analysis, two flavors of Independent Component Analysis, Slow Feature Analysis, Gaussian Classifiers, Growing Neural Gas, Fisher Discriminant Analysis, and Factor Analysis. MDP has been written in the context of theoretical research in neuroscience, but it has been designed to be helpful in any context where trainable data processing algorithms are used. Its simplicity on the user side together with the reusability of the implemented nodes make it also a valid educational tool. As its user base is steadily increasing, MDP appears as a good candidate for becoming a common repository of user-supplied, freely available, Python implemented data processing algorithms. http://mdp-toolkit.sourceforge.net

Speaker: Tiziano Zito (Institute for Theoretical Biology, Berlin)

Slides EuroPython2006MDPTalk.pdf EuroPython2006MDPTalk.sxi

14:35 Visualizing behavior of ambient sensor networks

Ambient sensor networks represent distributed systems that challenge the illusion that Moore's law will always facilitate more complex software in the near future. The need for extreme low power consumption in myriads of miniscule sensors is a driving force to reduce software again to its basics. It appears that good old concepts enable new animals like hopping and gossiping nano-agents. But a lot of validating experiments are yet to be done to understand and control behavior of sensor clouds in realistic ambient environments. This talk is about a framework to simulate and monitor dynamic sensor-networks in 3D, combining the capabilities of Blender, numpy and Python. Blender is used for modeling and animating 3D worlds. Cluster behavior is represented in numpy as scalable matrix algebra similar to Matlab. Python is the universal and transparent glue for any component.

Speaker: Theo De Ridder (Saxion Hogescholen)

Slides europy2006-tdr.pdf

15:10 Using Python in the Development of a Grid User Interface for Distributed Data

Details are presented of GANGA, the Grid user interface being developed to enable large-scale distributed data analysis within High Energy Physics. GANGA helps users to configure, execute, monitor and manage their large scale computing tasks. We show how the basic functionality implemented in a small GANGA core can be enhanced by tailored plugins provided by specific user communities. We show how Python metaclasses and descriptors are used to build user-friendly interfaces to the plugged modules in a dynamic way. The interface allows simultaneous use of an interactive prompt based on IPython, full scripting capabilities as well as a dynamically created GUI based on pyQt. We describe the optimisations developed for the serialization of GANGA objects and finally, we present GANGA approaches to the configuration and help systems.

Speaker: Alexander Soroko (UNIVERSITY OF OXFORD)

Slides GangaEP2006_2.pdf GangaEP2006_2.ppt

14:00 → 15:40 Web Frameworks

14:00 An Introduction to TurboGears

Since its release in September, TurboGears has quickly grown a large and active community of developers. With TurboGears 1.0 currently in testing, there is quite a bit to show off that hasn't been presented before. In the "20 Minute Wiki", I show the end-to-end creation of a simple application. In this presentation, I will present a feature tour (with code snippets) to highlight some of the high-level facilities TurboGears offers.

Speaker: Mr Kevin Dangoor (Blazing Things)

14:35 Pylons: A Modern Python Web Framework

Pylons is a lightweight web framework emphasising flexibility and rapid development. Pylons combines the very best ideas from the worlds of Ruby, Python and Perl, providing a structured but extremely flexible Python web framework. It's also one of the first projects to fully leverage the Web Server Gateway Interface standard which facilitates extensive re-use and flexibility — but only if you need it. Out of the box, Pylons uses best practice principles to make web development fast, flexible and easy. (www.pylonshq.com) This talk will take the audience on a whistle-stop tour of Pylons, from installing the software to deploying a finished application.

Speaker: Mr James Gardner (3aims.com)

Slides Pylons_final.pdf

15:10 Bebop: A Zope3-based Groupware

Bebop is an open source (GPL) groupware that tries to combine collaboration support and content management with a user-friendly interface. Group aspects (e.g. who is online, who works on what, versioning conflicts, etc.) are seamlessly integrated into the user's local workspace. Bebop comes in two forms: a web client for casual users, and a standalone client for users with the need for professional editing tools. The web client provides wiki, blog, news, and repository views on Zope3 standard content objects. As an Ajax application it offers live search, smart wiki links with various edit options, and WYSIWYG editing and merging. A two-way event notification (cf. Nevow's LivePages) for Zope3 is under development. Although the Ajax client feels in many respects like a standalone application, it still suffers from a limited integration with the desktop and editing tools. To overcome this major shortcoming of web-based applications a standalone client written in wxPython will be the major focus of the Bebop project. This client stores all content in the filesystem and shows in real time who's online, who's sharing the same point of view, and visualizes all modifications and versioning conflicts. The paper will focus on Bebop's architecture and sketch future developments. Bebop: http.//svn.kmrc.de LivePage: http://svn.zope.org/*checkout*/zope3org/trunk/src/zorg/live/README.txt

Speaker: Dr Uwe Oestermeier (IWM)

15:40 → 16:00 Coffee Break

16:00 → 17:40 Games

16:00 Pre-Mapping a GSM Network Environment for a Pervasive Game using Python for Series 60 Phones

Pervasive Games are a new type of game that takes place outside in the wild and makes sense of the user's context, often based on her position. Mobile phones are the perfect ubiquitous device for this type of game but usually come without a GPS device which could be used for positioning. Operator based positioning can deliver a GPS-compatible coordinate in latitude and longitude (WGS84), but this involves a fee for every position look-up and is only available on a few networks. Client based positioning based on the GSM network's cell IDs is an alternative solution, where the phone's current serving cell is utilized to infer the user's location either in an abstract graph space or in WGS84 coordinates by using look-up tables of previously seen and geocoded cell IDs. This talk covers how Python for Nokia Series 60 phones has helped us to collect the data for the client based positioning approach and how we use it to prepare for a location-based multiplayer game accross the 3 cities of Nottingham, Derby and Leicester which will go online on Valentines Day 2007. The game is going to run on a number of mobile phones. We are using Python for rapid prototyping of required tools and potentially also the gaming interface. Parts of the software could potentially be made available to the community. Parts of the software have been developed within a 6th Framework EU funded integrated project on pervasive gaming (IPerG) in which the author and his affiliation participate. Links: http://www.pervasive-gaming.org/ http://makinglovecity.blogspot.com/ http://www.lovecity.tv/

Speaker: Mr Leif Oppermann (University of Nottingham)

Link to IPerg Project http://www.pervasive-gaming.org/

Link to Python war-drive software for Nokia Series 60 phones and Win32 data post-processor http://www.mrl.nott.ac.uk/~lxo/ipergtools/

Link to Python wrapper for Contextphone for Nokia Series 60 phones http://www.cs.helsinki.fi/group/context/python.html

Live-demo material and discussion oppermann-livedemos.zip

Making of Lovecity Blog (incl. promo video) http://makinglovecity.blogspot.com/

Slides europython-oppermann-premapping.odp

16:35 Bub-n-bros = Bubble Bobble + 10 players + general craziness from Python's flexibly

Bub-n-bros is an Internet version of the original Bubble Bobble game: everyone play a dragon that fires bubbles with which he catches monsters. This version has a fast-paced crazy-bonuses feeling to it that is the true landmark of not only ten dragons jumping all around but a really flexible programming language that does not restrict inventiveness.

Speaker: Mr Armin Rigo (University of Düsseldorf)

Home page http://bub-n-bros.sourceforge.net/

17:10 LLG Python: Geometric Computing in Python for next generation games and entertainment

Next generation games and entertainment raise new questions in terms of architecture, design and development. Parallel processing hardware architectures enable disruptive approaches in terms of real time simulation and visualization. Storage capabilities grow ten folds, along with content creation and hyperlarge scenes crucial problems. Massively multiplayer online gaming brings brand new perspectives on networking applications, and concerns about participative content creation and the corresponding bandwidth issues. Finally, 3D makes its way to embedded, mobile devices, spawning with a number of specific difficulties. LLG Python proposes an original, Python based environment unifying volumic data representation and processing for real time applications. This unification through 3D programming and scripting enables defining solutions to many next generation gaming and entertainment upcoming challenges.

Speaker: Mr Jérémie Farret (Parallel Geometry Inc)

16:00 → 17:40 Python Language and Libraries

16:00 Designing Unicode-aware Applications in Python

The talk presents ways of designing Python applications to be Unicode-aware from ground up. I've held the talk at the LSM 2005 conference in Dijon, France and people were very interested. You can download the PDF for a preview: http://www.egenix.com/files/python/LSM2005-Developing-Unicode-aware-applications-in-Python.pdf

Speaker: Mr Marc-André Lemburg (eGenix.com)

Slides http://www.egenix.com/files/python/EPC2006-Developing-Unicode-aware-applications-in-Python.pdf

16:35 Internationalization in Python with PyICU - Chandler, a case study

As a cross platform desktop client, Chandler needed a rich and robust internationalization (i18n) strategy. Alas, though Python does have some good localization (l10n) support, it does not provide a robust i18n strategy covering things like: localizable searching, sorting, currency and date formating and boundary recognition. The Chandler project decided to bite the bullet and bring the ICU library into the Python fold providing a PyICU API. Though using PyICU, Chandler also uses the gettext model and .po format people in the Open Source community use and love for translation. The talk will cover the various aspects of the internationalization and localization challenges with code samples from Chandler and demonstration.

Speaker: Mr Philippe Bossut (OSAF)

Slides EuroPython_slides.zip

17:10 Common mistakes you can make using pytz and datetime

With pytz and datetime being included in the python2.4 distribution most people don't expect to have any trouble with using them. While they seem easy on the surface both of these libraries have a few gotchas that are very easy to encounter unless you really know them both. Working on a calendaring heavy web applications (SchoolTool/SchoolBell) I have encountered a lot of datetime related bugs myself. So I will try to demonstrate common mistakes made by developers and explain the right way of performing operations that are otherwise difficult to get right.

Speaker: Ignas Mikalajūnas (Programmers of Vilnius)

Slides pytz-datetime.pdf

16:00 → 17:40 Python in Science

16:00 Taming the beast: Using Python to Control ATLAS Software

ATLAS, one of the four experiments at the CERN LHC accelerator, uses the Athena/Gaudi component architecture to build and run its software applications. Python was initially introduced as a configuration language for the hundreds of C++ components, but soon, thanks to the development of a powerful C++ binding layer, it started pervading all application domains from job management, to application control to interactive analysis. In this talk we will survey both successes and challenges brought by the introduction of Python and we will discuss our ongoing efforts to use the flexibility of Python to make easier and safer for ATLAS physicists to build, configure and run their applications.

Speaker: David Quarrie (LBNL)

Slides Quarrie-EutoPython.pdf Quarrie-EutoPython.ppt

16:35 Interfacing Python and the C++ Frameworks used by High Energy Physicists

In this paper we present the developments in the area of interfacing Python with large-scale C++ frameworks, driven by the needs of the new generation of High Energy Physics experiments currently in preparation at CERN. The physics software being developed for detector simulation, data reconstruction, and data analysis is mainly written in C++. Yet, scripting is an essential functionality of the complete software system that we are providing to the physicists, and therefore it is essential to have a performing, easy to code to, and flexible interface from C++ to Python. Python is being used for application configuration, rapid prototyping, and interactive physics analysis. The Python interface has been built on top of the extended C++ reflection capabilities provided by such tools as CINT and Reflex. This reflection information, in terms of dynamic loadable libraries, can be used for the creation of Python bindings to C++ classes, functions, variables, etc., in a fully automated manner, since this information is already provided for by many end-user libraries for other purposes, such as object persistency. A consistent and automatic mapping of any C++ construct into an equi- purpose Python construct is achieved easily and elegantly. We finalize with a few use case examples demonstrating the capabilities of this interface.

Speaker: Dr Pere Mato (CERN)

Slides EPC_20060703.pdf

17:10 Finding Needles in a Huge DataStack

Many tools exist in the Python world to handle persistent data. Most of them are high-level wrappers to access well-known relational databases (Oracle, Postgres, MySQL...), while others are wrappers to highly-efficient, specific-purpose libraries (bsddb, NetCDF3...). Others have developed their own specific formats to fulfill their own requirements. In the data-hungry world of scientific computing, one usually prefers (with good reason) solutions that are not only fast but also well-tested and, perhaps more importantly, have outstanding backward and forward format compatibility. Scientific applications also tend to focus on the most efficient ways to find the "needles in the haystack" of massive amounts of data. We will begin the talk with a description of HDF5 [1], an emerging standard format to store scientific and other data. Its main features will be covered, and the contexts where it can be applied to an advantage will be discussed. We will then introduce PyTables [2], a well-known and widely adopted solution implemented in Python for manipulating potentially huge HDF5 datafiles easily and efficiently. We also plan to offer a sneak preview of the next-generation PyTables toolkit, with its greatly improved indexing and search capabilities. The PyTables discussion will include benchmarks of the latest versions, to give an idea of its lookup speed and performance as compared to other well-established standard databases and toolkits. Users will learn what they can expect from the next-generation PyTables and how it can help them to find specific data (the needle) in huge (terabytes and petabytes) datasets very rapidly. In conclusion, we will unfold our master plan for the future domination of the world by PyTables and its growing family. [1] http://hdf.ncsa.uiuc.edu/HDF5/ [2] http://www.pytables.org/

Speaker: Mr Altet Francesc (Cárabos Coop. V.)

Slides FindingNeedles.pdf

18:00 → 19:00 Keynote

18:00 Children First!

Why and how the worldwide programming community (and especially the Python community) should get interested in children's education, especially in the 3rd world, and help by making children's learning environments. I will show such an environment that I'd like to see done in Python (because I think it will spread better and be a maintained better around the world in Python).

Speaker: Dr Alan Kay

Tuesday, 4 July

09:00 → 10:40 Business and Applications

09:00 Achieving High Performance In Mercurial

Mercurial is a distributed revision control system designed for performance and scalability. Although written in Python, it is faster than most other revision control tools. This paper discusses the techniques used in Mercurial to achieve such high performance, and compares its performance on common operations with three other revision control systems: CVS, Subversion, and Perforce. It also introduces some novel software development techniques that are made possible by Mercurial's high performance.

Speaker: Bryan O'Sullivan (Mercurial)

Slides europython.pdf

Video europython.mov

09:35 Developing MailManager

MailManager is an email response management product written in Python. It is built on top of Zope and runs against an SQL database. The source code is freely available under the GPL. MailManager is sold to customers either as a web based application, an appliance server, or via support contracts. Additionally, customers often pay for modifications of the software, which are normally merged into the main development release. Some of the main challenges for development include the additional overheads of maintaining datasets for multiple revisions of the product for open source users, and ensuring compatability with a large range of target platforms. An international customer base requires i18n support throughout the product. Additionally, continual feature requests need to be developed and managed against the public release cycle. The development process makes heavy use of a test based methodology. BuildBot is used to run the test suite automatically on all supported platforms. Some of this code is also reused in order to provide extensive runtime monitoring of the product, and ensure it is functioning correctly. Logicalware (the company behind MailManager) was one of the first companies in the UK to receive VC funding for developing an open source product.

Speaker: Mr Campbell Kevin (Logicalware)

Slides europython.pdf

10:10 Snaking the Web

Two research projects of NEC and the University of Hannover could not be realized because of technology faults. With Python a 18 year old student from Germany solved the problems and created a new-class metasearch engine for the WWW. The development process with problems like high-volumes of data, web crawling, performances iusses and other topics was easy with Python like with no other programming language.

Speaker: Mr Markus Franz (Metager2, SuMa-eV)

Slides Snaking_the_Web.pdf Snaking_the_Web.ppt

text Snaking_the_Web.doc Snaking_the_Web.pdf

09:00 → 10:40 Python Language and Libraries

09:00 Python as a domain specific language

By using metaclasses and other powerful features of Python it is possible to use Python as a domain specific language. We will show how we replaced a domain specific language in CAPS with Python, and discuss our reasons for doing so. Using metaclasses and other meta-features, it is possible to greatly alter the behaviour of Python. We have exploited these to give us what we needed for our domain specific language, which is used to describe database object and to code fuctionality for them, while still retaining a clear syntax. The result is something not-quote-Python but still clear if you know what we are trying to do.

Speaker: Mr Anders Hammarquist (AB Strakt)

Slides domspec.pdf

09:35 The Chandler Repository, a Database for Python Objects

OSAF's flagship project, Chandler (http://chandler.osafoundation.org), is a personal information manager (PIM). As such, it needs to persist much of a user's personal data. Three years ago, OSAF embarked on developing an embedded desktop database for persisting the kinds of Python objects used in a PIM. Along with its data model, the Chandler Repository is the foundation layer in the Chandler software stack. In this talk, we would like to present some of the design decisions we made early on and discuss how they have served us over time. In particular, we'd like to address the topics of: - the language neutral data model - managing references between objects with natural indexes - handling concurrency without locks by merging changes - the pythonic schema API - queries via collections - caching via collection indexes and notifications

Speaker: Andi Vajda (OSAF)

Slides chandlerdb.pdf

10:10 zc.buildout, an automated application assembly tool

Applications and application-development environments are often built from parts, such as Python packages, databases, libraries, and configuration. The assembly process can be quite involved. It is best to use tools to automate the assembly process. Setuptools is a project that provides a packaging system for Python. It extends Distutils with the ability to define package dependencies and automated package installation. It provides automated platform-appropriate script generation. It allows multiple versions of packages to be installed, such that different applications can use different package versions as needed. Setuptools is targeted toward installing packages into a Python installation. It is not well suited to installing packages into a development environment. Setuptools assembles applications at run time, leading to undesirable non-determinism when new packages are installed. We have developed an application and framework, zc.buildout, that provides automated application assembly leveraging setuptools. It can be used to assemble any application, but it is especially well suited to and is designed for assembling Python applications. Applications are defined with configuration files. Configuration files specify a collection of parts, along with their configuration data, making up the application. Parts are implemented by recipes. Recipes are defined as setuptools packages. Recipes are provided for installing Python packages and scripts leveraging setuptools' automated installation facilities, providing an improved mechanism for leveraging setuptools in development environments and other situations where installing into a Python installation isn't appropriate. The buildout system provides install-time, rather than run-time application assembly, providing greater predictability.

Speaker: Mr James Fulton (Zope Corporation)

Slides EPBuildout.pdf

09:00 → 10:40 Refereed Papers

09:00 An Introduction to Test Driven Code Generation

Agile Software Development promotes the use of techniques such as Test Driven Development (TDD) and Automation in order to improve software quality and to reduce development time. Code generation represents a way to achieve automation, reducing repetitive and error-prone tasks. Code generation is well accepted, writing a code generator is not necessary that hard, however it is not trivial to decide when and how to embrace code generation. Moreover, it is even harder to embrace at the same time code generation and TDD, wondering for example "How to test drive generated code?" or "How to build a generator following a test driven approach?" This paper aims at providing hints to answer those questions. It presents an iterative approach named Test Driven Code Generation. The main principle is to gain knowledge about the application during the first iterations of its development process and then to identify how to implement code generation. As code generation should not drive you out of TDD, we provide hints to marry both approaches in order to empower your developments. Using a simple 3-tier web application, this paper is illustrated with the Python standard unittest module, CherryPy web application server and Cheetah templating system.

Speaker: Dr Raphael Marvie (LIFL -- University of Lille)

Paper MarvieTestDrivenCodeGeneration.pdf

Slides MarvieTestDrivenCodeGenerationSlides.pdf

09:35 Developing Ambient Displays for Collaborative Work

This paper discusses a prototype system known as the Ambient Workplace (AW) that lets people monitor work patterns within a group of co-workers. The AW provides information in the user's peripheral attention zone with the objective being that the user soaks up the information without needing to specifically attend to it. Information is displayed within standard applications such as the Windows Active Desktop, Outlook or Word. At present the system displays various types of awareness information, for example the number of interactions a specific user or group of users has initiated and whether they are online. It also displays global information about the volume and type of work for the entire group. The Ambient Workplace uses Python and displays information using Scalable Vector Graphics (SVG). It uses a client/server architecture built upon the XMPP instant messaging protocol and retrieves information from a MySQL database. The objective was to build a system which can be easily ported to other platforms such as mobile phones and smart boards as well as to leverage existing libraries while allowing rapid prototyping of the user interface.

Speaker: Dr Rod McCall (CRP- Gabriel Lippmann)

Paper europython.pdf

10:10 PyJIT: dynamic code generation from runtime data

PyJIT is a framework for providing just-in-time compilation from within Python programs. The idea is to generate machine code at runtime, and inline our data as we go. This can provide significant speed-ups versus compiled code, by reducing memory bandwidth use and simplifying the executable code. At the core we use the Low Level Virtual Machine (LLVM) which has facilities for creating machine dependant code on the fly. PyJIT handles conversion to LLVM Static Single Assignment form, and has a compiler that accepts a subset of the Python syntax, including basic control flow. We demonstrate applications in: vectorized operations and numerical linear algebra, tree structures for machine learning, and optimization techniques using interval arithmetic.

Speaker: Mr Simon Burton (National ICT Australia)

Paper SimonBurton.pdf

Slides talk.pdf

09:00 → 10:40 Web Frameworks

09:00 i18n made easy, illustration with CherryPy

After a quick introduction to i18n (internationalization), we will show how it is fast and efficient to turn an application into a multilingual application using the itools library. The powerful framework CherryPy will be used to highlight in a fully functional example, in particular the four following aspects: * automatic message extraction in Python code; * automatic message extraction in XML templates; * speed improvement by using one template per language; * language negotiation API. Those aspects allow the internationalizion of a Python application, even outside the Web context.

Speakers: Mr Hervé CAUWELIER (itaapy), Mr Nicolas DERAM (itaapy)

Slides i18n_made_easy.pdf

09:35 CPSBayes, a multipurpose naive bayesian classifier for Zope

Naive Bayesian classification is widely used in spam detection systems, like SpamAssassin. CPSBayes is a Zope 3 / Five product that provides a naive Bayesian classifier tool over a CMF portal, with a SQL backend storage. This talk presents the tool and its primary use case: classifying incomings emails in themes, before they become web documents sent in specific workflows. Moreover, the presentation focuses on other uses of the tool for other tasks over a CMS (Content Managment System) or an ECM (Entreprise Content Managment) like automatic filling of metadata. This kind of automated task enhances some features that often get less accurate when the document corpus grows because users never do those tasks (search, etc.)

Speaker: Mr Tarek Ziadé (Nuxeo)

Slides CPSBayes.odp CPSBayes.pdf

10:10 Version content in Plone with CMFEditions

With CMFEditions Plone content may be versioned. Around the conference a 1.0rc or 1.0final will be available. It works with all standard Plone content out of the box. It offers strong architectural support for future use cases. There are already a handful of sites productive with CMFEditions alpha versions.

Speaker: Mr Grégoire Weber (Europython 2006)

Slides EPC2006_CMFEditions.pdf

10:40 → 11:00 Coffee Break

11:00 → 12:40 Business and Applications

11:00 LiSoG - Linux Solution Group. Connect real users, technology, applications and businesses.

The Linux Solution Group (www.lisog.org) is a cooperation platform for companies and authorities with a strong interest in doing business or running applications based on Linux and Open Source. Members of the LiSoG range from global enterprises like IBM, Novell and Red Hat to small businesses, authorities and users. The session will explain the goals and targets of the LiSoG solution group. The speaker Niels Mache is a board member of the Linux Solution Group.

Speaker: Mr Niels Mache (struktur AG)

Slides EuroPython_LiSoG-1.pdf

11:35 ZEA Partner network explained

The partnership of Zea (www.zeapartners.org) is focused on growing open source and open source business by pooling resources for collective action as promotion and projects. With 20 partner companies in 11 countries, ZEA provides a broad reach of expertise in content management. The ZEA network currently totals a combined staff of over 150 employees and a turnover in excess of € 9 million. The talk will investigate the challenges facing network of Sme’s, the strategy and actions of Zea Partners. The speaker Xavier Heymans is CEO of Zea Partners.

Speaker: Mr Xavier Heymans (Zea Partners)

Slides EP_talk_v3.4.pdf

12:10 Introducing python into industrial environment applications

Two years have passed since the company I work for (SIA) decided to use Python to develop applications. Most of those applications are for pharmaceutical companies with high industrial and production needs. So, I would like to talk about why we have chosen python, about the main problems using Python with industrial SCADA frameworks and also about some results and tips. To wrap it up, I would like to comment on what we think the Python evolution within our company will be.

Speaker: Fabio Pliger (SIA s.r.l.)

Paper pythonInIndustrialEnvironment.doc pythonInIndustrialEnvironment.pdf

Slides Introducing_python_into_industrial_environment_applications.pdf Introducing_python_into_industrial_environment_applications.ppt

11:00 → 12:40 Python Language and Libraries

11:00 An Introduction to PyPy

PyPy is an implementation of Python written in Python itself. It aims are performance and flexibility. This talk will introduce the project and attempt to explain why it is interesting and useful. The intended audience is people who have heard of PyPy, have a vague idea that it is interesting but are not really sure why, though if you've never heard of PyPy I'll be delighted to explain things to you too :)

Speaker: Mr Michael Hudson (Heinrich Heine Universität Düsseldorf)

Slides intro.pdf

11:35 PyPy architecture session

In this session we will present and interactively discuss with the audience the basic architectural picture of PyPy - a next generation Python compiler and interpreter. We will emphasize emphasize various emerging possibilities enabled by our architecture and ask the audience for questions. In particular, we'll describe the following architectural pieces and point out extension and optimization possibilities: - Language Implementation: Bytecode Interpreter and Object Space interaction - Translation to low level languages (e.g. C/LLVM) - Translation to higher level languages (e.g. .NET/Squeak) - JIT-compiler architecture - Interweaving of Garbage Collection, threading and stackless operations into the translation process

Speakers: Holger Krekel (merlinux GmbH), Samuele Pedroni (AB Strakt)

12:10 What can PyPy do for you?

This talk describes novel features of the PyPy project (a next generation Python interpreter) which are made possible by its flexible architecture. The talk focuses mostly on example usages and less about their implementation. Specifically we will discuss and showcase the following: - lazy evaluation with the thunk object space - lightweight threadlets similar to those provided by stackless python - Oz-like dataflow variables with the logic object space - Writing compatible extension modules for PyPy and CPython with the PyPy extension compiler - The Javascript backend and its uses

Speakers: Mr Armin Rigo (researcher), Mr Carl Friedrich Bolz (student), Mr Eric van Riet Paap (programmer)

11:00 → 12:40 Python in Science

11:00 LLG Python: A Python based approach for high performance Parallel Geometric Computing

LLG Python defines a Python based programming paradigm for a new generation of geometric simulation, able to unify volumic data representation and processing for real time applications. It unifies in particular geometric and graphic pipelines, replacing parametric and polygonal surfaces with descriptive polynomials for generalized algebraic surfaces. This approach virtually enables scientific simulation interoperability for domains as various as robotics, GIS and territorial simulation, aeronautics or naval simulation. LLG Python’s high performance, Parallel Geometric Computing environment enables universal 3D programming to bring an answer current simulation challenges and limitations.

Speaker: Mr Jérémie Farret (Parallel Geometry Inc)

11:35 The Snake In The MeqTree: Using Python For Simulation And Calibration Of Radioastronomical Observations

Calibration of observational data from the next generation of radio telescopes presents a number of unique challenges, not only in terms of pure computational volume, but also in terms of managing complexity. In general, the calibration process involves constructing a combined model of the instrument and the observed sky, and fitting that model to the observations. Due to the great variety of sky sources and instruments, specific models can be very elaborate, but also very different from each other. The MeqTree package attempts to address this problem by providing a very flexible model construction & fitting toolkit which, in principle, should be applicable to all existing and future instruments. Using MeqTrees, inscrutably complicated and detailed models ("trees") may be constructed. Python plays two critical roles in taming that complexity: * TDL (Tree Definition Language), which is the language used to build up our models, is underpinned by Python. TDL allows for very rapid development of trees for simulation and calibration. * The MeqBrowser, written completely in Python/PyQt, is a graphical browser for running, examining and debugging the trees. The talk will provide a brief overview of radio interferometry, describe the calibration and simulation problems we face, and show how Python has enabled some crucial breakthroughs in the process.

Speaker: Dr Oleg Smirnov (NWO/ASTRON)

Slides europython2006-meqtrees-presentation.pdf

12:10 Python binding for Geant4 toolkit using Reflex/PyROOT

Geant4 is one of the principal toolkits used for the simulation of the passage of particles through matter. It is implemented in C++ and it exposes to the users a set of methods (of different classes) needed to construct a functional application. In other words, users need to interact with Geant4 objects via a C++ API and therefore users' Geant4 based applications are normally written in C++. In this paper we discuss how to use the Reflex/PyROOT tools to create a Python binding for the Geant4 classes. Such a binding gives the users the possibility of implementing their applications in Python as well as to interact and configure them from the Python prompt. Moreover, using the already existing Python binding for the ROOT data analysis framework, the Python binding for Geant4 allows to run interactively and simultaneously the two applications from the Python prompt. This proves to be very interesting, especially in the case of development and debugging of simulation applications. The advantanges of using the Reflex/PyROOT tools for creating a Python binding for C++ classes will be presented in this paper.

Speaker: Dr Witold Pokorski (CERN)

Slides PyG4EuroPy.pdf PyG4EuroPy.ppt

11:00 → 12:40 Web Frameworks

11:00 Frameworks Shootout

12:40 → 14:00 Lunch

14:00 → 15:40 Business and Applications

14:00 "What not how" - Questionnaire development with Zope & Python

Computers are well-suited for routine, recurring tasks such as data entry. In fields such as medicine effective use can lead to considerable improvements in productivity and patient care if doctors spend less time asking routine questions. As part of a research project at the University of Aberdeen I have been investigating possible systems. Any system should require as little maintenance by programmers as possible and should be configurable by managers, although the data captured would only be required for a doctor-patient interview, it should be stored in a reusable form. While there are several very questionnaire systems around they are generally geared towards statistical evaluation. Furthermore, while providing a great deal of flexibility in questionnaire and report layout, the data essentially remains locked within the application. It was decided to develop a prototype to support a generic, data-driven approach with a RDBMS backend for connection with other systems. To provide the greatest degree of flexibility the core part of the application requires very little programming. Zope, Python and PostgreSQL provide a good environment for this kind of requirement: PostgreSQL ensures data integrity, Python is well-suited for writing business rules, Zope is an excellent environment for integration. As a result most problems are of a conceptional nature. Due to the highly specific nature of parts of the project, it is unlikely that the software will be released.

Speaker: Mr Charlie Clark

14:35 On the usage of Python in the CERN Document Server's digital library and conference management tools

Python has been intensively used at CERN since 2001 by the CERN Document Server team to provide services in two areas: - Digital document management within the CDS Invenio application, running on top of MySQL DB - Digital conference management within the CDS Indico application, running on top of a ZOPE DB; and currently used to run EuroPython 06! In this presentation, after providing an overview of the usage and architecture of these two open source packages, we will describe the technical options that have been selected after comparison with other solutions. The choice of Python/MySQL versus Python/ZODB will be discussed. Finally, the role of the GNU Public Licensing in the evolution of CDS software with the creation of a world-wide consortium of developers will be underlined.

Speakers: Mr Jean-Yves Le Meur (CERN), Mr Thomas Baron (CERN)

Slides Europython.pdf Europython.ppt

15:10 TinyERP: opensource enterprise management software

Tiny ERP is a complete ERP (Enterprise Resource Planning) and CRM (Customer Relationship Management) package. Its main features include accounting (analytic and financial), production management (MRP), stock management, sales and purchases management, and much more. Technical features include flexible workflows, an object relational mapping (on top of PostgreSQL), a dynamically built GUI, an XML-RPC interface, and reports designable using OpenOffice (final output is in PDF). This talk will give a brief introduction about what Tiny ERP is, what it can do and how it works. The presentation will be divided in two parts. The first part will present the functionalities and end with a short live demo. The second part will focus on the technical aspects. It will include a presentation of the framework, how the different technologies involved (Python, PostgreSQL, XML-RPC, GTK, ...) are used, and some live demonstration of simple customization.

Speaker: Mr Gaëtan de Menten (Tiny SPRL)

14:00 → 15:40 Python Language and Libraries

14:00 Using decorators

I will talk about: - what decorators are (with examples); - how to write custom decorators; - when to use them and when not to use them; - expecially cool decorators; - 5 minutes of discussion about the decorator module I wrote.

Speaker: Dr Micheles Simionato (StatPro Italy)

Slides talk.html

14:35 Useful and New Modules

Python comes with batteries, and more are added with every release. It's hard to keep track of all of them, and I won't even try. My talk will cover some of the standard library modules I think more people should know about. I'll cover the new ctypes and ElementTree modules and older modules including subprocess, csv, and optparse. Depending on the time I'll also show examples using the bisect, heapq, and textwrap modules.

Speaker: Andrew Dalke Dalke (Dalke Scientific Software, LLC)

Slides dalke_europy06_modules.pdf

15:10 py.execnet: ad-hoc networking

Jan Balster presents a distributed computing approach and applications. There are different approaches to the distribution problem, each solution emphasises a special part of the problem. py.execnet provides an ad-hoc approach towards distributing programs which can work without any server side installation (except SSH and Python installed). It executes client-provided code fragments asynchronously, making server code maintenance superfluous and enables the clients to define the communication protocols. As part of the py lib py.execnet is developed in a test-driven style and is used in many different projects. After a quick introduction to using py.execnet this talk will provide interesting examples like robust hotsyncing of svn repositories or collecting system information from many (XEN) hosts.

Speaker: holger krekel (merlinux GmbH)

Slides 2006-europython-execnet.pdf

14:00 → 15:40 Web Frameworks

14:00 A Lucene-based cataloging solution for Zope-3 and CPS-3.4

Lucene is an open source project from the Apache Software Foundation written in Java. This is a high-performance, full-featured text search engine library. NXLucene, from Nuxeo SAS, is a multi-threaded remote server handling Lucene stores. It takes advantage of the freaking fast PyLucene Python bindings and uses Twisted for its implementation. It uses some parts of the Zope3 component architecture as well. NXLucene currently supports the XML-RPC and SOAP protocols. (Its roadmap even includes an ICE connector for the 1.x branch.) As well, NXlucene might be seen as a good example of what could be achieved using the best parts of different worlds (Java Lucene, PyLucene, Zope3, Twisted,...). nuxeo.lucene is a cataloging component integrated to the Zope3 application server currently offering an xml-rpc proxy to an NXLucene remote server. As well, It offers an abstraction for Python objects' cataloging strategy providing the ability to specify how Python objects should be indexed and retrieved from a Lucene store through NXLucene. (It is important to note here that any remote server providing an XML-RPC remote interface could be theoretically used.) CPSLuceneCatalog is a CPS-3.4.x specific product adding the CPS specific business rules to nuxeo.lucene. For example, it takes care of the way different versions of CPS documents should be indexed. CPSLuceneCatalog is a complete substitute for the ZCatalog which is showing its limits when dealing with millions of objects within the ZODB. CPSLuceneCatalog will be shipped along with the next major release of CPS, version 4, along with the JackRabbit JCR repository. The result is a big win on large scale deployments: - Indexing and searching are much faster and more scalable compared to ZCatalog - Indexing and searching are much more powerful than with ZCatalog - (Analysis, ranking, etc...) - Zope global performance is increased because Zope no longer deals with the indexing and searching business. NXLucene is an open source project under the LGPL. nuxeo.lucene is an open source project available under the ZPL. CPSLuceneCatalog is an open source project available under the GPL. For more information: - CPS Project: http://www.cps-project.org - Zope3: http://dev.zope.org/Zope3 - Apache Lucene: http://lucene.apache.org/java/docs/index.html - PyLucene: http://pylucene.osafoundation.org - NXLucene: http://www.cps-project.org/sections/projects/nxlucene - nuxeo.lucene: http://svn.nuxeo.org/trac/pub/browser/Zope3/nuxeo.lucene/trunk - CPSLuceneCatalog: http://svn.nuxeo.org/trac/pub/browser/CPS3/products/CPSLuceneCatalog/trunk - Nuxeo SAS: http://www.nuxeo.com

Speaker: Mr Julien Anguenot (Nuxeo SAS)

Slides ep2006-nuxeo_lucene.pdf

14:35 CPSSkins: theme editor for Zope3

CPSSkins is an application that allows site designers to compose pages by selecting and arranging UI elements on a canvas without having to use a programming language. This talk goes through the new exciting features found in the upcoming zope3 version of the application such as: - the new AJAX-based user interface - the WYSIWYG style editor - a simple API for creating custom portlets and widgets - the use of "perspectives" to control the visibility of elements on a page - the ability to create sites through-the-web and on the file-system - the XML import/export facility - the highly modular rendering engine - compatibility with Zope2/Five - ... The talk is targeted towards both developers and site designers. More information about CPSSkins can be found at http://www.z3lab.org

Speaker: Mr Jean-Marc Orliaguet (Chalmers)

15:10 Panel: Getting Started with the Zope Foundation

The Zope Foundation was legally formed on March 25, 2006. The first Foundation board will be elected in June 2006. This panel, consisting of Foundation Board members or their representatives, will present progress on forming the Foundation and, more importantly, solicit input and volunteers from members of the Zope community present.

Speaker: Mr James Fulton (Zope Corporation)

Slides ZFPanel.pdf

15:40 → 16:00 Coffee break

16:00 → 18:00 Lightning Talks

16:00 Lightning Talks

18:00 → 18:30 Break

18:30 → 19:30 Keynote

18:30 The Future of Python

The next major version of Python, nicknamed Python 3000 (or more prosaically Python 3.0), has been anticipated for a long time. For years I have been collecting and exploring ideas that were too radical for Python 2.x, and it's time to stop dreaming and start coding. In this keynote I will present the community process that will be used to complete the specification for Python 3000, as well as some of the major changes to the language and the remaining challenges.

Speaker: Mr Guido van Rossum (Google, inc)

19:30 → 20:30 Drink

20:30 → 23:00 Conference Dinner

Wednesday, 5 July

09:00 → 10:05 Business and Applications

09:00 → 10:40 Refereed Papers

09:00 Pyphant - A Python framework for modelling reusable data processing tasks

We present the Open Source framework Pyphant for the creation and application of data flow models. The central idea of this approach is to encapsulate each data processing step in one unit which we call a worker. A worker receives input via sockets and provides the results of its data processing via plugs. These can be inserted into other worker's sockets. The resulting directed graph is called a recipe. Classes for these objects comprise the Pyphant core. To implement actual processing steps Pyphant relies on third party plug-ins which extend the basic worker class and can be distributed in so-called Pyphant-worker-archives (PWA). On top of the core, Pyphant offers a data exchange layer based on scipy arrays and PIL images which facilitates the interoperability of the workers. A third layer comprises textual and graphical user interfaces. The latter allows for the interactive construction of recipes, the former for the batch processing of data. Our contribution discusses the Pyphant framework and presents example recipes for certain scientific data analysis tasks taken from image processing and the solution of ill-posed problems.

Speaker: Mr Klaus Zimmermann (Freiburger Materialforschungszentrum, Universität Freiburg)

Paper Europython2006-paper.pdf

Slides Europython2006-talk.pdf

09:35 Deep Integration of Python with Semantic Web Technologies

The Semantic Web is a vision for the future of the Web in which information is given explicit meaning, making it easier for machines to automatically process and integrate the information available on the Web. The Semantic Web will build on the well known language stack, part of which is the Web Ontology Language (OWL). Semantic Python (SETH) is a software effort to deeply integrate python and the description logic (DL) subset of the OWL, i.e. extend python to seamlessly support a logic programming paradigm. The deep integration of both languages introduces the notion of importing the OWL-DL into the programming context so that OWL classes can be used alongside classed defined normally. In this article we present a metaclass-based implementation of the deep integration ideas, which is a promising way of achieving such integration. The implementation is an early Python prototype supporting in-line class and property declaration, instance creation and simple triple-based queries. The implementation is backed up by the well known OWL-DL reasoner Pellet. The integration of the Python and OWL-DL through metaclass programming provides a unique approach, which can extend the current python-based web frameworks and provide the needed support for the Semantic Web technologies.

Speaker: Mr Marian Babik (Institute of Informatics, Slovak Academy of Sciences)

Minutes http://seth-scripting.sourceforge.net

Paper BabikSemanticWeb.pdf

Slides seth2.pdf seth.ppt

10:10 Implementation of a Transaction-based Peer-to-Peer Protocol

The paper describes a lightweight implementation of a peer-to-peer protocol. The implementation is intended as a testbed for ideas concerning the utilization of the peer-to-peer paradigm. The protocol takes the Gnutella protocol as a starting point, although the present implementation differs from the Gnutella protocol regarding intent as well as routing solutions. The protocol is implemented in Python since various data types and modules offered by Python make it possible to limit the code to a manageable size. The GUI is implemented with Tkinter. The design has two substantial features. Firstly, the protocol is transaction- based. As a consequence, the pong messages are no longer required since every successfully transferred message, independent of type, is a sign that a node is active. An adaptive ping algorithm further reduces the load on bandwidth. Secondly, there is only one entry point to the router. The way in which the router communicates with the GUI is symmetrical to the way in which it communicates with the network. This means that the connections between the router and the GUI are characterized by socket communication and protocol messages. This results in a fairly independent user interface, which creates a basis for further utilization of peer-to-peer systems.

Speaker: Ms Sofia Nygård (Åbo Akademi University)

Paper NygardP2P.pdf

09:00 → 10:40 Teaching

09:00 Python Academy - Teaching Python in Germany

Python Academy is a teaching firm that specializes in Python and Python related topics. It offers courses for beginners, programmers in other languages and scientists. It also provides Python-Trainers the opportunity to teach at its training center in Leipzig, Germany. Teaching languages are German and English. Besides offering courses it hosts the Leipzig Python User Group at its monthly meetings. It is the leading organizer of a Python-Workshop in September of this year in Leipzig. Other activities include speeches at different occasion about Python and contributions to a translation of an English open source book into German. Python Academy participated in initiative "Informatikjahr" (http://www.informatikjahr.de/) by the German Ministry for Education and Research. with the slogan "Specialists as Programmers". Experiences in combining teaching in the business sector and community activities will be presented. Python Academy is seeking collaboration with Python trainers that are interested in teaching their special Python topic in Germany.

Speaker: Dr Mike Müller (Python Academy)

Slides PythonAcademy.pdf

09:35 The African Python: Programming and Training in South Africa

Python has become the language of choice for bioinformatics, especially in teaching bioinformatics students to program. Bioinformaticists students come from various backgrounds including biology, computer science, mathematics, statistics and physics. While many of these disciplines encourage programming skills and structured thinking, biologists often have a hard time adapting to the world of computer programming when immersed at post-graduate level. Python programming and training in South Africa will be discussed broadly, followed by specific reference to the strategies followed by the South African National Bioinformatics Network community in their integrated national training programme. The landscape of Python software development for Bioinformatics in South Africa will also be introduced.

Speaker: Prof. Fourie Joubert (University of Pretoria)

10:10 Liberlab, a pocket lab for all

The Open Source project Liberlab aims to promote scientific experimentation through the creation and use of a digital lab at a very low cost ( 15 €/$). Its modular and open design encourages original uses, particularly in the field of education, and can also be used to learn about robotics, automation, human- machine interface or interactive arts. The heart of the project is based on the ongoing improvements of microcontrollers. These low price integrated circuits are like tiny and autonomous "computers" used in many devices (DVD players, cars, etc.). Instead of using them in an autonomous way Liberlab combines the computing power of a PC with the commands and measuring capabilities of the microcontroller. Liberlab is available under the free GPL licence with a GUI application (Tkinter) and a Python module to allow users to build their own programs using Python. The presentation will explain the technological choices for this project and show examples of usages with Python modules like Vpython, Xturtles and CherryPy.

Speaker: Mr Francois Schnell (ULP Multimedia)

Slides Liberlab-EN-EuroPython2006.odp Liberlab-EN-EuroPython2006.pdf

09:00 → 10:40 Web Frameworks

09:00 Templating Systems Compared and Contrasted

This talk is going to compare and contrast the various approaches available for templating in python web frameworks. A brief introduction to some of the main flavours will be given along with a discussion of their relative strengths and weaknesses. With luck, the audience will leave with a clearer idea of the options available to them!

Speaker: Mr Chris Withers (Simplistix Ltd)

10:10 JSON-RPC - makes web services communication simple

For web/browser-based applications/AJAX-applications it is important to efficiently communicate to web services to exchange data. There are exsisting protocalls, e.g. SOAP the not so Simple Object Access Protocol, that are rich in features but rather complex. This complexity is not needed for a lot of use cases. This is where JSON-RPC fits into the picture. It is a simple yet powerful RPC protocol which defines how services and clients should communicate with each other.

Speaker: Mr Jan-Klaas Kollhof (n/a)

10:40 → 11:00 Coffee Break

11:00 → 12:40 Agile Development

11:00 Kill -1: process refactoring in the PyPy project

In this talk we will present the experiences of running a collaborative OSS project within a EU-funded consortium structure. We will briefly present the initial decision process for integrating the community and the commercial aspects of the PyPy project. We will show how agile practices within the development team, primarily sprint-driven methodology resulted in a need for process refactoring and how a new agile management approach was implemented. We will spice up the analysis of the main drivers behind this change by refererring to Hershey-Blanchards Situational Leadership model.

Speaker: Mrs Beatric During (Change Maker)

11:35 Users’ participation in the design process of Open Source Software communities: the case of Python

In this talk, we aim at analyzing the ways members of open-source software communities, especially users, participate in the software design process. The general objective of this research in cognitive ergonomics is to understand activities occurring during the design process in order to better support collaborative work, greater interaction between various stakeholders, and construction of design projects memory. In our current work, we focus on the Python community. In a first study, we analyze online discussions between participants engaged in the Python Enhancement Proposal or PEP design process. We propose an alternative approach to threading to represent online discussions: it is based on the quoting practices as a relevant link between messages. We also show the influence of participants status in design-oriented online discussions and highlight the evaluative nature of design activities, i.e. pair reviewing mechanisms. A second study, still in progress, aims at understanding the “Python galaxy”, the links between the different communities in this galaxy, and the language evolution process from the idea of language evolution in one particular application domain, through its acceptance by one or several communities, to the PEP and its related modules implementations. The analysis of a “pushed-by-users” PEP extended design process shows how users may participate in the language evolution process, in particular through mechanisms of cross-participation between communities. This talk will give us the opportunity to get feedback from the Python community on our research and could engage interested Python members into a reflective approach about their collaborative practices.

Speaker: Ms Flore Barcellini (INRIA-Eiffel Team)

Annex to presentation Barcellini-Europython06-annex.pdf

A study of online discussions in an Open-Source Software Community: Reconstructing thematic coherence and argumentation from quotation practices https://hal.inria.fr/inria-00001000

Presentation Barcellini-Europython06.pdf

Thematic Coherence and Quotation Practices in OSS Design-Oriented Online Discussions https://hal.inria.fr/inria-00001001

12:10 From agile development to agile evolution of enterprise systems

The aim of this talk is to share my experience in the use of a practical architectural framework for the improvement of enterprise business systems. This framework uses the dynamic language Jython and agile development practices. This presentation is complementary to my presentation at the Plone conference 2005 in Vienna (“The use of Plone for enterprise solutions”) – it covers the technical and practical aspects of agile evolution of enterprise systems.

Speaker: Dr Alexander Samarin (SAMARIN.BIZ)

Slides EuroPython_conf_-_CERN_-_2006.pdf EuroPython_conf_-_CERN_-_2006.ppt

11:00 → 12:40 Misfits

11:00 subversioned system configuration

Holger Krekel presents "vadm", an open-source tool enabling full non-intrusive versioning of unix system configuration files and directories. Multiple administrators can collaborate and communicate over the setup of one machine. Under the hood, vadm uses subversion and the "py lib" and is easy to learn if you know how to use the "svn" command line already. The talk will also present future directions like supporting remote management of a cluster of machines.

Speaker: Mr holger krekel (merlinux GmbH)

Slides vadm.pdf

11:35 Come on and plug me in! Writing and testing plugins for Bazaar

Bazaar is a revision control system written entirely in Python. Programmers can use Bazaar's plugin system to provide new options, features and facilities. We demonstrate writing a plugin for Bazaar and describe what having a plugin system has done to and for Bazaar.

Speakers: Mr David Allouche (Canonical Limited), Mr Robert Collins (Canonical Limited)

Slides come_on_over_and_plug_me_in.odp

11:00 → 12:40 Teaching

11:00 Vision: VIsual Software IntegratiON

Understanding the amazingly complex biological systems sustaining life requires integrating, analyzing and understanding huge amounts of data. Computers are the tools of choice for such a task. However, profound knowledge of biology is needed for analyzing the data and learning from it. It is impossible to foresee the multitude of ways data can be visualized or computational methods can be combined to test hypotheses and often, it is assumed that in order to use computers to their full potential, scientists have to become programmers. We have explored the visual programming paradigm as a way to empower scientists with the ability to interactively program applications without having to worry about data structures or syntactical details of a programming language (even as simple and clean as Python). We have developed Vision: a software component that supports visual programming, and written adapters exposing the functionality of many Python packages in this environment. The concept of visual programming in not new however, the interpretive nature of the Python language allows for powerful and elegant solutions to many limitations witnessed in other similar tools. In this paper we will present Vision, highlight fundamental differences with other tools, and discuss benefits and challenges associated with this approach.

Speaker: Prof. Michel Sanner (The Scripps Research Institute)

Slides EuroPythonSanner2.pdf

12:10 xturtle - an extended turtle module for Python as a vehicle for teaching programming concepts

A new extended Tkinter based turtle module will be presented: (1) Motives and pedagogical goals. (2) The design of the extended module. (3) The underlying archtecture especially in respect of possible extensions and portings. (4) A set of sample scripts covering a wide range from elementary to rather sophisticated. (5) turtle graphics as a backbone for an introductory progamming course/book. Finally (6) a discussion will be initiated about the presented module as a starting point for a replacement for the existing turtle module of the Python standard distribution.

Speaker: Mr Gregor Lingl (BRG 16)

Slides xturtle-Europython2006.odp xturtle-Europython2006.pdf

11:00 → 12:40 Web Frameworks

11:00 Zope: The June releases

It's the second time that the Zope project has made releases according to the 6 month release schedule. Zope 2.10 and Zope 3.3 come with numerous new features, improvements and refactorings. This talk will give an overview of the changes in the "June releases" and point out some planned features for the upcoming release cycle.

Speaker: Mr Philipp von Weitershausen (none)

Slides

• june-releases.pdf
• shootout.pdf
• slides
• testbrowser-lightning.pdf

11:35 Tramline, big files are fun!

We at Pareto have created a streaming video Portal on top of Plone. It is created utilizing Plone's CMS capabilities combined with other open source packages. Because large binary data (like videos) can hurt the performance of the Zope database (ZODB) we set up Tramline. Tramline is a mod_python program which filters incoming post data. When it notices a file upload it extracts the data from it and puts that into a file. Then it replaces the post body with an id matching the filename. Upon a get it filters the response headers to see if the body is a Tramline id. In case it is it will replace the response body with the contents of the file stored on disk. This way Tramline ensures all binary file data is kept on disk instead of in the database. Yet it makes development and testing without it no different than you would normally. In my talk I would like to explain the principles and usage of Tramline. I will do this using our use case as a backdrop.

Speaker: Mr Jeroen Vloothuis (Pareto)

12:10 Linktally: Ranking popular pages in a CMS

Linktally works around typical CMS roadblocks like high-read, low-write databases, clustering and extensive caching to provide a approximation to page popularity.

Speaker: Mr Martijn Pieters (Pareto)

Slides epc2006-linktally.pdf

12:40 → 14:00 Lunch

14:00 → 15:40 Agile Development

14:00 Managing the Launchpad team at Canonical

Steve Alexander talks about managing the Launchpad team: 16 Python programmers from around the world working on a complex database application. Topics include: Effective IRC meetings, Conference VOIP calls, Code review, Distributed source code management, Automated testing, Sprints and meetings.

Speaker: Steve Alexander (Canonical)

Slides distributed-team.pdf

14:35 Managing a distributed company

This talk will discuss the experiences with implementing agile and distributed work methods in a small company that is involved in various international projects. The vision of working collaboratively, distributed and with shared responsibilities somehow contradicts contractual commitments and customer relations. Lene Wagner, manager of the distributed open source company merlinux, describes experiences and methods how to combine this within the commercial context of a small enterprise. The talk discusses shared decision models and peer-review strategies and how to manage outer and inner commitments. It deals with how to implement formal structures serving both agile processes and legal requirements. The talk will also describe problems, methods and findings of handling a reliable distributed communication via virtual channels.

Speaker: Lene Wagner (merlinux GmbH)

Slides distributed-management.pdf

15:10 Agile customer management: successes and failures

I will talk about our company's experience in applying certain XP practices when dealing with clients, how different clients understand these practises and react to them and what kind of problems we have trying to explain and apply XP. About the author: Aistė Kesminaitė is the managing director of a young but already distinguished team of software engineers from Lithuania. She and her team use XP and other agile practises for most aspects of the business.

Speaker: Ms Aiste Kesminaite (Programmers of Vilnius)

Slides AgileCustomerManagement.pdf

14:00 → 15:40 Misfits

14:00 SCREWS - An Architecture For Simulating Errors in Web Servers

SCREWS is a flexible architecture for simulating errors in web servers, intended for testing of error detection and recovery tools. The flexibility comes from the ability to write "SCREWSlets", tiny Python scripts which determine whether to send an error, and what kind.

Speaker: Mr Moshe Zadka (B-hive Networks)

Slides screwing-webservers.html

14:35 Dual Scripting in a Virtual Reality Engine. Embedding Python in XVR

In this talk we present the embedding of Python inside the eXtreme Virtual Reality (XVR) Engine. XVR is an advanced and lightweight system for the development of Virtual Reality applications both for the Web and for 3D Immersive systems. This system has been extensively used in European Projects for the construction of high quality 3D graphic applications enhanced with VR devices. XVR applications are written in the S3D scripting language and compiled into a bytecode representation executed by the XVR Virtual Machine. The scripting language and the virtual machine are specialized and optimized for the manipulation of 3D entities and efficient object oriented programming. The XVR system allows to develop and deploy 3D application easily by asking the developer only to write the core rendering loop and place the application in a Web page. The XVR Engine provides natively a set of classes for creating Virtual Reality applications ranging from 3D graphics (both high level classes and low level OpenGL functions), 3D sound and physics. Moreover it is possible to extend such features with external native modules providing the support for new devices, simulation engines or rendering techniques. At runtime the external modules are loaded and their classes integrated in the system namespace. PYXVR is a XVR extension that allows to embed a Python script inside a XVR application or, putting it in another way, write a Virtual Reality application using the XVR Engine features. Typically the XVR application loads the PYXVR extension, executes the scripts and invokes Python in response to the rendering (OnFrame) and animation (OnTimer) events of the XVR Engine. The result is a dual script environment in which the two scripting engines cooperate for providing the best of the two worlds. The Python scripts are able to access all the functions and classes defined by XVR (both scripted and native), while the XVR script accesses the Python scripts through the eval and callback functions There are some advantages to using Python inside a XVR application. First there is the possibility of modifying and extending the application using the script, because the XVR application is completely defined at compilation time. Then there is the possibility of using the Python libraries and multi-threading for enhancing the XVR application. Despite the advantages there are some drawbacks that should be taken into account. First there is the aspect of security. XVR applications are typically executed in the Web Browser and the XVR classes respect the security requirements of this environment. The PYXVR extension allows the unrestricted import of modules and for this reason it is currently limited to local XVR applications. The second disadvantage of PYXVR for 3D Web application is the weight of the Python engine whose core shared library is in the order of one megabyte, a size that is equivalent to the whole XVR engine comprising the Virtual Reality features. With regards to the execution speed, the S3D scripts are faster than the Python ones in managing objects and external entities because during the off-line compilation of the script all the names and functions are known and encoded in the byte-code. The simpler type space of S3D provides also additional optimizations when dealing with 3D entities. The talk discusses the overall PYXVR extension, the aspects of integration between the two environments, the multi-threaded features and finally a performance evaluation of this solution. Concluding, the PYXVR extension presented in this talk can be used by XVR developers for enhancing their XVR applications and at the same time by Python developers for the fast prototyping of Virtual Reality applications. Information about XVR can be found at http://www.vrmedia.it More information on PYXVR will be shortly provided on: http://wiki.vrmedia.it/index.php?title=PYXVR

Speakers: Mr Emanuele Ruffaldi (PERCRO Lab, Scuola S.Anna, Pisa), Mr Walter Aprile (PERCRO Lab, Scuola S.Anna, Pisa)

Project Description Project Description

Slides pyxvr.pdf

15:10 Speed up your Python code

Does it seem your Python code (or even Python code in general) is too slow? If yes, come to this talk. It explains: - which rules should guide you when optimizing Python code - when you should optimize at all - how to find the bottlenecks in your code - what big-O notation is and what it's good for - which changes may help to speed up your Python code - using hardware, algorithms or Python-specific idioms. This talk is for developers of Python code. The less experience you have, the more you will profit. If you are familiar with software development but new to Python, especially the Python-specific tips will interest you.

Speaker: Dr Stefan Schwarzer (SSchwarzer.com)

Slides optimization_talk.pdf

14:00 → 15:40 Web Frameworks

14:00 Generic Functions in Turbogears

Generic functions are a powerful form of abstraction promoting the DRY principle and in the case of frameworks lend themselves to declarative programming and allow users to seamlessly extend functionality with minimal boilerplate. In this talk common uses cases for generic functions in TurboGears will be presented based on concrete examples followed by a discussion on problems we encountered using generic functions, as implemented in RuleDispatch package from PEAK, both on framework and user level, and how these can be mitigated.

Speaker: Mr Simon Belak (TurboGears)

Slides generic_functions.pdf generic_functions.ppt

15:40 → 16:00 Coffee Break

16:00 → 18:00 Lightning Talks

16:00 Lightning Talks