Sessions at EuroPython 2011 on Tuesday 21st June

Share the lessons learned from a decade of core Python development, what worked and what didn't. Look at the development process and thinking behind some of Python's successful APIs and ones that leave something to be desired. Learn general principles for designing a good API for public consumption.

The target audience are pythoneers, pythonistas and enthusiasts who want to learn how to put together a web project in a professional way

The training aims at exploring all the necessary elements for successfully putting together a web project. It provides knowledge and best practices about a range of aspects which must be taken into account when developing for the web. At the end, the participants are expected to have a fully-working, deployed and running web project with all the basics covered where they can borrow from in future projects.

List of contents:

Basics about web servers and differences between a client program and a web service.
Architecture of a web project.
Overview of web security concepts and best practices.
Deployment techniques and tools
Development/Staging/Production environments and how to manage them successfully in a Python web project. Use of VCS and Virtualenv.
Comparison of Python web frameworks.
Testing with Python and Selenium.
Best practices for logging and backups.
Statistics and how to take advantage of them.
Benchmarking and why it is a key factor for success.
Scalability: layered architecture and Cloud Computing.
Caching structures and tools. Cache-breaking techniques.

Additionally the basics of Django are presented as it will be used as a base for the project. It is also included how to deploy in AWS using boto.

In questo talk spiegherò quali opportunità ci offre il game-engine Panda3D nel momento in cui vogliamo creare un videogioco da zero. Spiegherò com'è strutturato al suo interno e i concetti di base per capire come funziona, ma mostrerò anche prove pratiche e pezzi di codice.

Può partecipare chiunque abbia una conoscenza di base di Python, anche se non ha mai lavorato con applicazioni realtime 3D. L'obiettivo è mostrare come creare un semplice videogioco che risponda agli input immessi dall'utente e come utilizzare al meglio questo potente engine.

The talk will give an introduction to the concepts used in the Python Database API and relational databases in general. Connection, cursors and transactions are discussed, and their use in a typical Python database application are demonstrated. The talk will also touch upon some advanced database programming techniques and discuss best practices.

Messaging is a well established domain in information technology and can greatly improve the scalability and throughput of a system when employed appropriately. Message queues can be used to achieve

• spatial decoupling i.e. the systems that produce and consume messages may be deployed on different machines, networks, continents etc.
• temporal decoupling i.e. a system can enqueue a message and carry on without waiting for the message consumer.

We use e.g. messaging in [http://openquake.org] OpenQuake to distribute calculations of [http://openquake.org/about/gem/] seismic hazard and the respective risk to human lives and infrastructure.

There is a huge number of messaging patterns identified in the industry [7] and a small selection of these will be presented to whet your appetite :-)

AMQP [1] is a fairly new and open messaging standard with a number of freely available open source message brokers (RabbitMQ [2], ZeroMQ [3], qpid [4] etc.) with different features and performance trade-offs.

In the course of the presentation you will be
* introduced to AMQP concepts and jargon
* introduced to available Python AMQP bindings (focussing on an asynchronous (txAMQP [5]) and a synchronous variant (most likely kombu [6]))
* shown code examples demonstrating how to use these Python bindings

The presentation (45 minutes in total) is structured as follows:
* 7.5 minutes for messaging concepts and patterns
* 7.5 minutes for AMQP concepts
* 5 minutes for an overview of the Python bindings for AMQP
* 10 minutes for txAMQP examples (asynchronous bindings)
* 10 minutes for kombu examples (synchronous bindings)
* 5 minutes for questions

References:

• http://www.amqp.org/
• http://www.rabbitmq.com/
• http://www.zeromq.org/
• http://qpid.apache.org/
• https://launchpad.net/txamqp
• http://ask.github.com/kombu/
• http://www.amazon.com/dp/0321200...

The session is divided into two parts, of roughly 2 hours each. People who
are interested only in the first part, can leave the session after it.
However, the first part is a prerequisite for the second one, thus people are
not advised to join in the middle of the session

The session is meant to be highly interactive. People are invited to bring
their own laptop and try things by themselves.

Part 1: Run your application under PyPy
--------------------------------------------------

This tutorial is targeted to Python users who want to run their favorite
Python application under PyPy, and exploit the most of it. The following
topics will be covered:

- how to fix/avoid CPython implementation details (e.g., refcounting)

- general overview of how the PyPy JIT works

- how to optimize your program for the PyPy JIT

- how to view and interpret the traces produced by the JIT

- how to tweak the parameters of the JIT and the GC

- how to use existing CPython C extensions on PyPy, and fix them if
necessary

Part 2: Write your own interpreter with PyPy
-------------------------------------------------------

PyPy is not only a Python interpreter, but also a toolchain to implement
dynamic languages. This tutorial is targeted to people who want to implement
their own programming languages, or who simply want to know more about how the
PyPy JIT works internally.

The students will be given the source code for a toy language implemented in
RPython. They will learn:

- how to translate it to C using the PyPy translation toolchain

- what are the "hints" needed by the JIT generator, and how to place them

Then, they will be challenged to add the proper hints to the toy interpreter,
to get the best result with the JIT.

Python is currently at a crossroads: Python 2 has taken it from a quiet word-of-mouth language to primetime, with many companies around the world using it and an ever-increasing global marketshare of the programming world. But now comes Python 3, the first version of the language that is not backwards compatible with previous releases.

What does this mean? Are all my Python programs going to break? Will I have to rewrite everything? How much time do I have? When is Python 2 going to be EOL'd? Is the language undergoing a complete rewrite and will I even recognize it? What are the changes between Python 2 and 3 anyway? Also, the next generation is already here, as Python 3 is over two years old now. What has been ported so far, and what is its current status? Are migration plans or transition tools available? If I want to start learning Python, should I do Python 2 or Python 3? Are all Python 2 books obsolete?

We will attempt to answer all of these questions and more. Join us!

OUTLINE/TOPICS

• Python 2 vs. Python 3
• Introduction to Python 3
• Backwards Compatibility
• Generational Changes
• Key Differences
• Role of Remaining Python 2.x releases
• Transition & Migration Plans & Tools
• Futures

With the growth of the web, how we publish is changing. Paper alone is not enough, web pages are also required. And for many web pages it is not enough to rely on the browser's print capabilities. Sphinx, used since 2008 for Python's documentation, is a creative response to this tension.

This talk will take a broader view of the problem. For example, many browsers support web fonts for display but not for printing. Mathematics on web pages is still difficult, but SVG holds out much promise not only for mathematics but for tables and other complex typeset material. Achieving accessibility remains difficult.

Based on over 15 year's experience in print and electronic publishing, this talk will survey problems and emerging solutions. Software and sites covered include LaTeX, PDF, SVG, MathJax, web-fonts, PediaPress, Sphinx and arXiv.

rdflib is a python library implementing a database with various triples back-end, parser, data serializers, SPARQL is a Python interface to extract/insert triples. We integrated it in Django reusing the database connection and exposing an ORM interface, along with full-text search on literals. This presentation shows a django-rdflib case study with a PostgreSQL backend in Brain Architecture Management System (http://brancusi1.usc.edu) - a neuroscientific project for the University of Southern California. Benefits of the flexible RDF structure will be shown, allowing researchers to insert free format data, making data public with a customizable serialization and use the powerful full-text search integrated in PostgreSQL.

Objective: show attendees an effective combination of RDF, PostgreSQL full-text search and Django ORM via django-rdflib.

Requirements: Django familiarity.

A partire da Python 3 il vecchio tipo intero ("int") è stato abbandonato, lasciando il posto al "long", che l'ha rimpiazzato mettendo a disposizione un unico, uniforme tipo per lavorare con gli interi.

Tuttavia, i long richiedono una struttura più complessa che ha ridotto un po' le prestazioni di Python 3.x.

Un'idea è si è fatta strada dando un'occhiata alla loro implementazione, che può aiutare a migliorare la situazione in scenari comuni (usando interi "corti").

Verrà presentata una struttura leggermente modificata, e confrontata col vecchio PyIntObject e l'attuale PyLongObject di Python 3.2, assieme ad alcune ottimizzazioni, pensieri, e problemi che si sono presentati, che mostreranno lo sforzo richiesto da un simile cambiamento a un elemento del "cuore" di Python.

This talk is the updated and especially enhanced of the "Python and PostgreSQL - a match made in heaven" talk of EP 2006, CERN, Switzerland.

PostgreSQL and Python share more then the first letter: their communities have great similiarities; their development processes are really comparable; their licenses and their openness to academics AND business (on a technical and communitie perspective) are big pluses.

We will have a look at those similiarities and learn why PostgreSQL is really the database sister to Python. There will be an overview of PostgreSQL, information of how to connect PostgreSQL and Python; how PostgreSQL streaming replication works and what it can do for you, how PL/Python helps to have Web 2.5 JSON storage and handling right inside PostgreSQL. We will show that YESQL is also a valid answer to many data storage qeuestions.

To Relate or Not to Relate, that is the question raised by the NoSQL movement. There is a lot of buzz about Couch, Casandra, MongoDB, and other non relational databases, and at the same time there are decades of hard work that's gone into optimizing databases built around the relational model.

I would actually argue that there is no such thing as a NoSQL database -- there are a variety of compelling options to relational database -- each of which have different features and different performance characteristics. So no one-sized fits all comparison will do. So, I'll try to outline a general taxonomy for persistence mechanisms, and then proceed to comparing relational DB's to their new friends in practice.

The talk will contain quite a few stories from the trenches with CouchDB, MongoDB, MySQL, Postgres, Tokyo Cabinet, ZODB, and other databases, and will help you think about the data storage needs of your applications in new ways.

Building scalable web applications may seem like a distant problem, but the problem is not thinking about it before it's too late. This talk will focus on designing a scalable web application before it needs to be (and avoiding the premature optimization dilemma). It will cover topics such as efficient usage of your database, appropriate caching (and invalidation!), and what the speaker considers as best practices.

Clojure is a modern Lisp dialect symbiotic with the Java Virtual Machine and designed for concurrency. Clojure is compiled to byte-code and yet is fully dynamic. It is very oriented towards functional programming and manages state change in a controlled environment with software transactional memory (STM). Since Clojure is a Lisp dialect, it retains the code-as-data philosophy and has a powerful macro system

Using the Jython, an implementation of the Python programming language written in Java, it is possible to call Clojure from Python and call Python from Clojure, using the JVM as an interoperability platform.

After a brief introduction of the main Clojure features, the presentation will show how Jython and Clojure can be used together.

No previous knowledge of Clojure (or Lisp) is assumed nor required.

GeoDjango is the "world-class geographic web framework" everyone has probably heard of. The purpose of this talk, targeted at people familiar with Django itself, is to introduce in more details the capabilities of this framework.

After learning the basics of Geographic Information Systems, we will see:

• how to get started with a GeoDjango installation,
• how to import, store and query spatial data,
• how to geo-enable your forms to allow user-generated spatial data,
• how to serialize and display your data using the different formats and mapping frameworks such as OpenLayers and Polymaps.

During this talk we will be building a simple GeoDjango application to illustrate the different concepts introduced.

La prima parte del talk introdurra' la storia di uWSGI, dall'idea iniziale alla messa in produzione dei primi lavori, fino alla sua inclusione nei progetti Cherokee e Nginx.

Seguira' una serie di esempi di deploy in ambienti ostili (a livello di sicurezza, non faremo deploy nella jungla) o con risorse fortemente limitate fino all'utilizzo delle funzionalita' integrate per il clustering.

Il talk si rivolge a tutti gli sviluppatori di applicazioni web che sono alla ricerca di un ambiente robusto e veloce per i propri lavori, o a chi gia' utilizza uWSGI e vuole
conoscere qualcuna delle nuove funzionalita' introdotte nel ramo di sviluppo.

How Python was used to implement a tool for the daily backup of an over 50 terabyte distributed data warehouse based on Greenplum Database technology.

The talk covers our experiences, from the initial customer requirements to the first alpha release of the tool, describing the main issues we faced and the Python modules we adopted to address them, while using agile methods.

Though the application is not currently available as an open-source project, the talk gives valuable insights into the development of distributed and parallel applications using Python.

Django benefits from a thriving third-party ecosystem. This talk will take a deep look at three of the components I have found most useful in my own projects: Haystack for full-text search, Celery for offline processing and Fabric for automated deployments. I'll discuss how we use them for Lanyrd.com, and demonstrate why they deserve a permanent place in your toolbox.

This tutorial will work through a series of real-world examples, showing how an understanding of the tools built into the Python interpreter or included in the standard library can be combined to solve difficult problems clearly and Pythonically. We will also discuss when and how to reach beyond the standard library when needed to address difficult algorithmic and optimization problems.

Abstract:
Whether you’re an independent developer or development manager in a large company, “the cloud” is on everyone’s mind. But just because it’s in the cloud, doesn’t mean development and deployment is effortless. The cloud presents infrastructure and development challenges in a new way.

In this presentation, ActiveState's Gisle Aas will share best practices in building and deploying a Python-centric LAMP stack(s) on the cloud for a range of web-based applications from simple Django site to HPC GPU Clusters.

Based on ActiveState’s experiences, Gisle will discuss the challenges faced and lessons learned in building an infrastructure to deploy web applications to the cloud with Python.

You will learn about:
•Which packages are critical for a secure, Python-centric LAMP stack (and what it takes to build them)!
•Tips for developing, deploying, and scaling Python applicaitons in the cloud
•How to use Python to connect and build infrastructure to support and manage your deployment

Point Nine provides operations outsourcing and support to large and complex financial institutions.

As part of our day to day responsibilities we are required to process our client's trading activity which generally involves receiving data in various formats and through various protocols, apply transformations, validations and enrichment processes and distribute the resulting data to various third parties, in short Data Plumbing.

The goal of this talk is to introduce the audience to the (vast) field of financial data processing which we believe presents a tremendous opportunity for python and it's community and provide a brief overview of Point Nine's deployment of Python as the main framework for all data plumbing activities.

Viri is a system for automatic distribution and execution of Python code on remote machines. This is especially useful when dealing with a large group of hosts.

With Viri, Sysadmins can write their own scripts, and easily distribute and execute them on any number of remote machines. Depending on the number of computers to administrate, Viri can save thousands of hours, that Sysadmins would spend transferring files, logging into remote hosts, and waiting for the scripts to finish. Viri automates the whole process.

Viri can also be useful for remotely managing host settings. It should work together with an application where the information about hosts would be maintained. This information can include cron tasks, firewall rules, backup settings,... After a simple Integration of this application with your Viri infrastructure, you can change any settings in the application, and see how it gets applied on the target host automatically.

The talk will cover next topics:
* Introduction to Viri
* Live demo on how to install Viri, write a Viri task, and execute it in a remote host
* Security concerns using Viri

Check Viri project page at: http://www.viriproject.com

In questo talk, mosteremo i tool e l'infastruttura che rende molto semplice la creazione di progetti Python in Ubunut, e la loro distribuzione a milioni di utenti. Verranno mostrati vari tool: Launchpad, Quickly e i PPA (personal package archiving).

This talk will give an outline of the advances that Google have made in API delivery over the last year, and how it is relevant to you as a Python developer. The talk is suitable for beginners and advanced developers.

We will describe the underlying platform, and the built-in features that all Google APIs inherit.

We will focus on how the Python libraries for this API platform are generated and can be used as a single library that doesn't require updating with API updates, as Python lends itself perfectly to the nature of this platform.

This will be both technical and light talk, introducing these important subjects:

- the new scripting language PyHP, a solution to create dynamic web pages using the Python scripting language server side, a-la PHP, but smarter.

- the LiWE (Lightweight Web Environment) Web Framework, a new and robust web framework written in both JavaScript and Python that will help you creating amazing websites.

- how this new amazing technologies can help you date girls (this will be the light and funny part of the talk)

Prerequisites:

• Very basic knowledge of PHP
• Basic Python
• Basic / None JavaScript

It's impossible to use Python without learning about lists, dictionaries and tuples, and most people have at least heard about sets. These four collection types are so important and useful that Python has special syntax for creating them.

Fewer people know about Python's other built-in collection data types and algorithms. A deque supports fast appends and pops from both ends and is great for breath-first searches, the heapq module helps you construct a priority queue on top of lists, and the bisect module is handy for quick binary searches of an already sorted list.

The defaultdict uses the dict __missing__ hook as a better solution to setdefault, OrderedDict is a dictionary that preserves insertion order, and Counter is a dictionary specialized for counting hashable objects. A namedtuple is handy if you want to support both index and attribute lookups for the same item, and a frozenset is a hashable form of a set which can be used as keys in a dictionary or set.

My talk will go over these 8 different classes and modules. I'll give concrete examples of how to use them and why they are useful. The target audience is intermediate programmers who are familiar with the Python's standard data types and with data types in general, but who don't know all of the functionality available in modern Python.

È molto facile accedere ad un database con Python e ci sono molti ORM che
permettono un alto livello di astrazione. Da qui c'é ancora una lunga strada
per arrivare a manipolare interattivamente i dati anche per semplici
compiti.

Sqlkit cerca di coprire questa distanza fornendo alcuni mega-widgets che
permettono di costruire ogni applicazione GUI o accedere direttamente ai
dati con l'applicazione 'sqledit', che viene distribuita con sqlkit. Sqlkit
è costruita con PyGTK e SQLAlchemy.

Questa presentazione esplora alcune fra le più potenti caratteristiche di
sqlkit e mostra quanto sia semplice costruire piccoli programmini ad uso
personale o applicazioni ricche ed articolate. Si focalizza principalmente su
due punti: quanto sia facile creare maschere per editare dati (anche
relazioni on2many o many2many, grazie al modo originale di definire i
layout) e al sistema di template basato su OpenOffice che rende
incredibilmente semplice creare report.

Questa presentazione vuole mostrare come sqlkit può essere usato sia come
framework di sviluppo di applicazioni, sia come strumento che ci aiuta
mentre sviluppiamo altre applicazioni (es.: Django, OpenERP,... ).

Per rendere la presentazione più graduale, sfrutteremo il sistema di
configurazione di sqledit Partendo da una configurazione minima -un URL-
aggiungeremo elementi fino ad ottenere una vera applicazione.

(if there are no more 45-minute speaking slots, 30-minutes will work too.)

The medical industry has long been dominated by custom software written by manufacturers of medical equipment. With the widespread use of lower-cost computing power and abundance of software developers using cost-beneficial open source development tools, it is no surprise that this is a rapidly-growing field in software engineering. In this talk, I will describe some of my experiences using Python and other open source tools, temporarily transitioning from the world of the web and Internet development, jumping into the medical industry, an experience much like being a fish out of water.
The experiences of working in this field, specifically developing software for use in clinical trials. We describe the use of open source tools for such software development, the required integration with closed-source software, and the documentation rigor that is necessary in a field under the jurisdiction of the US Food and Drug Administration (FDA). In particular, I'll describe direct experience in building an application for the use of analyzing spinal fractures and the various tools that make up the application suite, whose primary development language was Python. We will also discuss the particular role of the my employer at the time in the clinical trials process and elaborate on the data flow that was necessary for all medical applications developed at the firm, not just the one in particular.

Teaser for full tutorial: http://lanyrd.com/2011/europytho...

plac is general purpose tool than can be used to define command-oriented domain specific languages (DSLs). In its simplest form it can be used as a command-line arguments parser with an easier-to-use API than argparse. It can also be used to replace the cmd module in the standard library. Moreover it can be used to automatize functional tests and for much more. The talk will touch upon many use cases where plac can make your life as a developer simpler and better.

Technically Plac is a wrapper over argparse and works in all versions of Python starting from Python 2.3 up to Python 3.2. In Python 3.X it takes advantage of function annotations to define the parser in a declarative way, instead of the imperative way of argparse. In Python 2.X it uses decorators instead, to reach the same goal.