EuroPython 2010 Talks Abstracts
Talk Streams
- Python in Action
- Alternative Implementations
- Build, Packaging & Deployment
- Community
- Databases
- Documentation, Tools & Library
- Education
- Games Programming
- UI Programming
- Python Language
- Mobile Computing
- Multimedia
- Network
- Python 3
- Science
- Testing
- Web Programming
Python in Action
The Trojan Snake
From toolbox to platform… How we introduced Python to a museum.
Talk, 45 minutes (general)
Over time, a large institution can amass a patchwork of bespoke applications, especially on the web. I will discuss how Python libraries like BeautifulSoup and lxml helped the V&A regain control of its web presence and internal systems.
I will cover how integrated task management and source control with Trac helps balance the many and varied demands on a museum tech team. This forms a key pillar in the "Python as platform" argument.
Finally, the inevitable Django bit. How Django delivers API access to over 1 million museum records and how this is a catalyst for the complete redevelopment of the V&A site.
The Trails of EasyExtend
How EasyExtend 4 turns programming language transformation into ordinary Python scripting
Talk, 45 minutes (advanced)
EasyExtend started as a framework for building extension languages for Python. As such it was advocated and presented for the first time at EuroPython 2007.
In the meantime EasyExtend has undergone two major shifts. The first shift was due to the introduction of a novel parser generator architecture called Trail, which supports the concept of trace based parsing. With Trail the parser generator moved from the periphery to the center of EasyExtend. The second shift was caused by the discovery that with the aid of Trail and techniques like parse tree interpolation each language has equal weight within the system. In the second step Python was moved from the center to the periphery.
Over the time EasyExtend became more principled, abstract and elegant. It is a host for a plethora of techniques related to grammars, state machines and languages. In my talk I will touch some of the most relevant aspects of EasyExtend and motivate using it in everyday programming.
OpenERP demonstration
Generic presentation of OpenERP software
Talk, 45 minutes (intermediate)
Short presentation of the possibilities that OpenERP offer. The stress will be put on the main modules used on the software:
- CRM
- Sales flow
- Workflow
- Dashboard
- Customization
- DMS
Python and EDA
Current Electronic Design Automation tools leave many gaps for Python
Talk, 45 minutes (intermediate)
The TCL scripting language was designed for the EDA industry and is embedded in many tools. Perl tends to be the scripting language used by those creating design flows by linking together EDA tools. Despite this, their are signs of Python being used in niches; and my own experiments have shown that Python can be used productively, and innovatively in the world of chip design.
This talk will give an introduction to the world of EDA and how scripting languages used in it; mention a couple of Python-based tools that are available now, and a couple of my successes in using, hopes and fears for Python in this field.
Python from the Inside-Out
Experiences introducing into the core of a large legacy C++ application
Talk, 45 minutes (general)
Summary
We will present our experiences with successfully introducing Python into RMS, a large legacy C++ application and the flagship product for Roxar. We will discuss the hurdles we faced in realizing our ideas (political, technical, and cultural), and how we addressed them. We will also talk about the somewhat unorthodox path by which Python found its way into RMS (i.e. by replacing the entire persistence layer), as well as the difficulties and sometimes unexpected benefits of taking this approach. We present this as a Python success story, a practical how-to, and a morale booster for those hoping to do the same thing.
Outline
- What we do and how we're using Python
- How we decided to use Python
- How we convinced the decision-makers
- Our roadmap for introducing Python into the code
- Obstacles to the adoption of Python (and solutions!)
- Technical difficulties with implementation and development
- Benefits we've realized from using Python
- Lessons learned and where we're going
KBUS: A simple messaging system
A Linux kernel-based messaging system, tested and explained using Python
Talk, 45 minutes (general)
KBUS provides a simple to understand and easy to use message passing mechanism. The current implementation uses a Linux kernel module to provide the actual mechanics of the system. From the very start of the project, Python has been used to unit-test the code, as an exemplar of how to provide an API for KBUS, and as a basis for writing documentation and examples.
This is a simple introduction to how to use KBUS, an explanation of why one might want to, and a look at where the project may be going in the future.
Spell-checking adventures
Implementing Hunspell as a Windows DLL, usable from many versions of Python
Talk, 45 minutes (intermediate)
objective
make a spell checker available
under Windows
- although the approach should work under Linux
in as many of Python 2.x, 3.x and Ironpython as possible
- aside: why are so few extensions available for Python 3.x?
precompiled
discovery
choosing a spelling checker
- history: ASpell, Ispell, MySpell, Hunspell
building it
preferably, using an open-source compiler
MSYS and MinGW
- compared to Cygwin
as a DLL
tidying up the exported functions
interface design
how DLLs work
- C vs C++ interface
interface options
different ways extensions are constructed
no Python in DLL
Python in interface layer of DLL
- SWIG
Python deep into DLL
why does this matter?
convenience of use
- example calling code
- introduction to Hunspell interface
ctypes
- availability
- typical ctypes method (with code example)
- a few gotchas
testing
existing test suite
- Unicode issues (non-BMP)
IronPython issues
installer
- creating an installer
future work
- performance investigation
Building a python web app
Lessons learned in building a python web app from scratch using web frameworks
Talk, 45 minutes (intermediate)
This talk is meant to give an attendee a thorough understanding of what it takes to build, and market a python based web app from scratch. The talk will use MediaCore, an open-source video CMS, as an example.
The following points outline the structure of this talk:
- Introduction - what is MediaCore, project goals, development model
- Django to TurboGears to Pylons - the long road of development, and lessons learned along the way. To date we have spent over 3000 hours on our app, and have learned a huge amount about the various Python frameworks. We would like to share this knowledge with the community.
- SQLAlchemy vs. Django ORM - How they stack up against each other, and what we've found in using both.
- Launching MediaCore as an open source project, and what we've learned. This would include a discussion on the importance of branding, A/B testing, marketing, and promotional strategies.
- Conclusion
Stuart Bowness has been taken ill, so this talk will be given by two of his colleagues, Anthony Theocharis & Nathan Wright.
Pythonic Parallelism with CSP
Concurrent Sequential Processes, why it is good, and what it can do for you.
Talk, 45 minutes (intermediate)
Concurrent Sequential Processes (CSP) is a 30 year old theory that will revolutionize programming in the new multi-core computing era. Although the original theory is couched in mathematical terms, you don't have to be a mathematician to use CSP to structure programs. APIs such as Python-CSP do all that for you. Python is great for structuring computations but not good for 'grunt' calculations, ctypes and SWIG with C and C++ come in handy for this.
Arduino and Python
How we used arduino and python for prototyping new user interfaces
Talk, 45 minutes (general)
This talk will cover how we used arduino and python in a rapid prototyping session to develop new user experiences / controls for interacting with media. The arduino platform is an open source hardware platform with onboard microcontroller, useful for creating everything from sensors through to robots.
As well as covering one of the actual resulting tools, it will also cover how to get started with arduino and python, and strategies for integrating the two systems together, along with testing. The system to be discussed includes motorised feedback, computer vision, and orientation detection, and integrating python, arduino, Kamaelia and Open CV.
Running Ghana VAT on Python
Lessons learned from a VAT collection project in Ghana, Africa
Talk, 45 minutes (intermediate)
During the last year eGenix.com has run a custom project for a client in Switzerland with the aim of creating an end-to-end country-wide online VAT collection system for the Ghana VAT Office.
During the project we've learned a few important lessons, the more interesting of which I'd like to share with you.
Python, Arduino and Mech Music
Multi-axis machine to "program" musical punched cards
Talk, 45 minutes (intermediate)
Old mechanical instruments are still alive... but they need to be programmed! No CDs, no MP3 recorders, no hard disks to store musics. Only punched cards. Nowadays, it's unthinkable (and quite boring) to manually punch cards. Music composers should concentrate on conceiving and arranging music instead of punching cards. Python and Arduino (a well-known open-source physical computing platform) make a good team to conceive and realize multi-axis machine controllers and user interfaces able to program and control low-cost machine tools. A low-cost card puncher has been designed, realized and will be presented during the talk.
Presentation outlines will be: - a short description of Arduino main characteristics; - communication mechanisms between Python and Arduino; - machine control functionalities (velocity/position control, axes position reset, motor and encoder integration); - program flow management, communication synchronisation and machine error management; - MIDI files to machine program generation. A final demonstration of the card puncher functioning will be shown.
Python for Javascript Apps
How Python powers development of large-scale Javascript applications
Talk, 45 minutes (general)
qooxdoo (qooxdoo.org) is an open-source Javascript framework that specialises in a pure Javascript, object-oriented development of rich Internet applications. Large applications of that type need tool support to automatically track dependencies, compress and optimise Javascript, manage images and other resources, and handle internationalization aspects. This talk is an experience report about developing and maintaining qooxdoo's tool chain, which is entirely written in Python.
Behind the scenes, code developed with qooxdoo is subject to various transformations. The code is compressed, variable names are shortened and string access is optimised. Code for variants can be pruned, and can automatically be distributed across several files. All this is to optimise load size and startup time of the application in the browser. As additional developer aid, dependencies among pieces of code are automatically detected, code can be normalized and formatted, API documentation can be extracted from comments, translateable strings can be extracted into .po files, or a unit test application be generated.
This is all done with Python. The heart of many of those features is the construction of a syntax tree from the involved Javascript code, which supports the code optimisations and dependency tracking. But many more utilities have been added around this core. The entire functionality is controlled by a configuration system that uses a JSON-based syntax, and implements its own simple scheme of objects and inheritance to allow re-use on the config level.
The talk will give an overview of qooxdoo's tool chain and highlight specific parts, challenges met, and lessons learned.
Testing coders
How to make sure you don't interview dummies
Grzegorz Jakacki (Codility)
Tomasz Walen (Codility)
Talk, 45 minutes (advanced)
Hiring coders is a tricky, bad coders infiltrating your team can wreak havoc. Codility is a tool to filter out non-programming "programmers" before they incur any damage. Codility administers on-line programming tests. We want to show how Codility implementation harnesses Python introspection to perform code scalability tests in 10 different programming languages at once.
JavaScript 4 Pythonistas
Resources to help Python (and JavaScript) programmers with JavaScript
Meeting, 45 minutes (general)
For all interested in developing (and using) Pythonic experience, guides, software and training material for JavaScript programming.
This ranges from understanding the difference between the Python and JavaScript object models through to Python to JavaScript translators, and including Pythonic JavaScript libraries.
Web Collaboration and Python
Collaborating on the Internet with MoinMoin and other popular Python Web applications
Talk, 45 minutes (general)
Web sites such as those for Python and EuroPython offer collaborative sections in the form of a Wiki (the PythonInfo and EuroPython Wiki respectively), allowing users to communicate and to collectively pool their knowledge and experience in a Web site that rapidly overtakes more traditionally curated content. For some sites, such as python.org, the intention is to have a place where people can write down their notes related to a topic; for others, such as europython.eu, the idea is to have an informal forum for planning and for sharing hints and tips about the conference. Some sites go further and provide a Wiki as a platform to replace a number of other tools in addition to permitting collaboration and communication between its members. For example, the FSFE Fellowship Wiki seeks to replace a content management system as a repository for contributed content, community group coordination, and for maintaining a community event calendar.
Despite the intense publicity for various Python Web technologies at the framework and library level, applications such as MoinMoin (providing Wiki solutions), Mercurial (version control and repository browsing), ViewVC (repository browsing), Roundup (bug tracking), Trac (Wiki, repository browsing, bug tracking) and Mailman (mailing list management) quietly enjoy widespread use on the public Internet, particularly in support of Free Software development. As Trac and Launchpad demonstrate, many projects have a need for support in connection with a number of different activities and functions, and as a consequence, project hosting provider services (both free of charge and paid for) are perhaps more widely used than ever before.
This talk covers some of the practical elements of supporting collaborative environments, concentrating mainly on MoinMoin and its use in various Free Software projects and initiatives. It also investigates the potential for combining the widespread but arguably under-appreciated Web applications of the Python world in order to provide readily usable solutions for the management of projects and common activities, whether purely of a software nature, or of a more social nature, such as in the organisation of events like the EuroPython conference.
Open Data & coding data.gov.uk
Designing the UK Government's open data catalog with decentralised, wiki edits in a Pylons framework
by David Read
Talk, 45 minutes (general)
CKAN is a web catalog of open data, built in Python and forms the basis of the UK Government's data.gov.uk website which was launched by Tim Berners-Lee in January 2010. We will introduce the current excitement behind Open Data, Linked Data and CKAN's potential with them both.
Behind CKAN's simple catalog of data are several interesting features:
- wiki-style public crowd-sourcing to feed-back improvements and expand the data catalog.
- git/mercurial-style push/pull/merge of data between multiple websites running CKAN, to share catalog data between several government and public.
- Debian-style 'packaging' of open data, to easily get, link and mash data.
We will discuss how these 'big ideas' have been developed in CKAN and how performed in improving the data and how it's used.
CKAN is based on the flexible web framework 'Pylons' and uses SQLAlchemy to provide an object model of the database. We'll give a brief overview of how these work and mention challenges we faced in practice.
Background
The liberation of Ordnance Survey data in April caused headlines, but it is one of thousands of datasets created by the UK Government that have been opened up in 2010 in the data.gov.uk initiative. The Open Knowledge Foundation is at the forefront of providing access to these data and has been working with them since September 2009 to customise CKAN to their requirements as a data catalogue.
In the same way that software package management (e.g. apt-get) can easily install a stack of open software, we've designed CKAN to do the same for data. We will share our vision for open data, as we work towards it being easily downloaded, linked and mashed-up.
Now CKAN has been successfully adopted and rolled out in websites by organisations and governments around the world. We see CKAN as having an increasingly important role in reducing barriers to discovering, obtaining and using open data, which can only increase its value for society.
Tryton as an ERP and Framework
A quick demo on Tryton as a Pythonic framework and ERP system.
Talk, 45 minutes (intermediate)
A quick demo of the following capabilities of Tryton:
Quickly build a module Demonstrate how quick it is to build a simple application on the framework.
OpenOffice Reports Build a simple report on the same model/application in couple of minutes
Email Framework Build a template on the embedded e-mail framework for the same object to demonstrate how email is integrated
Web Framework Simple demo on the same object on how these details could be published to the web
This simply covers the RAD concept Tryton embraces on the surface level
What Goes Round, Comes Round
NoSQL: How fashion repeats, or Old is New
Talk, 45 minutes (general)
In the early 80s I had a serious look at RDBMSs, both RSI Oracle and MISTRESS, which was rapidly renamed to Empress for fairly obvious reasons, and is still available as a commercial product. They were powerful products, and had one thing in common: the resources required meant that they were unusable on affordable hardware of the time. Looking around, we found an ISAM-based 4GL product which more closely matched our needs and resources.
ISAM filing systems were pioneered by IBM (and still form the basis of DB2) and offer fast access to data using a key:value look up, like an on-disk Python dictionary.
I have used ISAM filing systems ever since, although in recent years this has become unfashionable and has attracted some criticism.
All of a sudden, key:value systems have become fashionable again under the banner of NoSQL - Not Only SQL, proving yet again that fashion is re-cycled.
In this talk I will explain the principles of the Thyme ISAM filing system and demonstarte its Python-based development system, including automatic PyQt screen generator and Xappy full text indexing.
Pyradiso Rapid Software Development
How the multiprocessing module takes Python to a next level of software development.
Talk, 45 minutes (intermediate)
Summary
This really is the presentation of a very early conceptual definition for a project that aims to take Python powered software to the next level of computing. In order to achieve this we want to build on the existing Python infrastructure to create a framework to rapidly create a distributed application. The goal of the presentation is to bounce these ideas around in the audience, get feedback on the ideas and to attract people interested in working on the project.
Outline
Python is a well established programming language in a broad range of applications and on a broad range of platforms. The recent releases, starting from 2.6 and upwards, have added a lot of interesting capabilities that have hindered deployments and usage in certain environments. Interesting additions and extensions are:
- The multi processing module: take away the limitations imposed by the GIL, enable true native usage of all available processing power in multi core/multi machine environments.
- https/ssl support (using pyOpenSSL): enable safety in a hostile web/networking environment. Previously already existing modules and distributions of interest are:
- CherryPy: native Python webserver, easy to use, easy to configure.
- Portable Python: take all your Python apps on a USB stick and run them everywhere.
- Python GUI frameworks. The final deliverable of the project should be a framework that allows for easy and rapid development of distributed and highly scalable applications. The framework should honor the following requirements:
- Applications are inherently client-server type or web application type, so the clients can be native clients or browser based. Both types of application can be equally easily developed and deployed.
- It must be easy to protect and encrypt the client-server communications.
- BApplications can be easily configured to consist of multiple processes; either for enhanced performance on a single multi core machine or for real distributed applications (N-tier). The complexities of managing the multiple (remote or local)processes, of sharing and synchronizing data; of distributing task load across the different processes must be hidden for the user of the framework. All individual processes are single threaded by design principle. Data persistence: can be either SQL based or NoSQL based. Code generation: the business objects representing the data of the application should be auto-generated by the framework from a definition (e.g. XML based definition) as much as possible (synchronization, (de)serialization, construction and initialization, getter- and setter- methods, inclusion in collections, …). The user can then derive from the framework generated classes to add or inject functionality.
The presentation will elaborate on these ideas, present some initial thoughts and ideas, tentative implementations for research purposes. I hope to open a discussion on this topic with the audience to further identify challenges and concerns, solutions and approaches and to attract people interested in working on this, both as a framework developer and as a framework user (application developer).
JessyInk
A set of Python-based extensions to create presentations in Inkscape.
Talk, 45 minutes (general)
Python is well known as a language for scripting and extending many popular open-source applications. As such it provides incredible opportunities to create new and powerful tools with very little code. In this talk, JessyInk, a collection of extensions for the well-known vector-graphics editing application Inkscape will be presented. Using JessyInk, Inkscape can be turned into an editor for presentations that can be played in any modern browser.
Starting off, a quick introduction to Inkscape and its extension system will be provided. Subsequently, the basics of creating and deploying Python-based extensions for Inkscape will be presented. The JessyInk extensions will be used to illustrate how a variety of different tasks can be accomplished. In the course of this discussion, the design ideas underlying JessyInk will be laid out as well. Hence, insights into the details as well as the overarching architecture of JessyInk will be provided.
It will be shown how the versatility of Python was instrumental for the quick development of JessyInk. It provided the essential glue to join the editing power and ease of a desktop application with the exciting possibilities of standards based browsers as a presentation platform. The talk will be concluded by a showcase of the features currently supported by JessyInk. Furthermore, ideas for new features and future direction of development will be presented.
Code Clinic
Bring your code along to show off or to receive advice on.
Tutorial, Half day (general)
Bring your code along to show off or to receive advice on.
Aerodynamics and Pianos
Quick blast through some python technical computing topics
Talk, 60 minutes (intermediate)
This talk is a quick blast through some python technical computing topics based on some commercially developed aerodynamics applications and a piano music application.
Real-world examples show the potential of each topic, and a getting-started example gives delegates a jumping-off point.
The topics are:
PyQt (GUI package) Using graphs in a GUI - and interacting with the graphs (Chaco) Wrapping 'C' at runtime (by end users!) (Cheetah + Cython) Working with Mr Gates (C#/.Net, Word, Excel, COM) Aircraft maths with SciPy (air flows inside! a wing, simulate landing dynamics, Butterworth filter) Good old fashioned text file parsing and data correlation (defaultdict / keep it simple) A mediator pattern use-case - working with graphs - make it testable, keep it de-coupled Produce linear, (like an essay) software design documentation automatically (doc strings and introspection) Make piano sounds with FluidSynth, sound fonts and Python Midi See also http://www.petes-piano.com Can a computer work out music notation from sound data only? Making music notation graphics with PyQt, and a novel use of fonts Using PyQt's extensibility to make your graphics interactive A challenge for the community - a public web service to generate sheet music notation from MP3 sound files
Alternative Implementations
HotPy - A comparison
How do high-performance VMs for Python work? A comparison of HotPy, PyPy and Unladen Swallow
Talk, 45 minutes (advanced)
HotPy, PyPy and Unladen Swallow promise large speed ups over CPython. How do they intend to do this?
To make a fast virtual machine, all the subsystems of that VM must be fast. In this talk we will look at the various subsystems of the VM, including: JIT compilation, optimisation control, garbage collection and concurrency. What are the constraints on the subsystem? What are "ideal" characteristics of that subsystem? How do HotPy, PyPy and UnladenSwallow implement it? How close do they get to the ideal?
I will pay special attention to optimisation control (determining what to optimise and when) as I think this is what differentiates the three projects the most.
I will try to be fair in my appraisal of the three VMs, but as I am the author of HotPy I may be biased.
Finally I will make an informed, but almost certainly wrong, guess as to how much faster than CPython these VMs can get.
The Ring of Python
Sauron principles versus informed voluntary co-operation
Talk, 45 minutes (beginners)
CPython 2.5/2.6/3.1, Jython, IronPython, PyPy,StacklessPython, UnladenSwallow, Cython ... what do we make of all these cool interpreter projects and versions? Is it all about speed? And if not, how fast are they? What about the standard library, packaging and deployment? Where does competition help and where does it hamper? I am going to present my views and ideas and foster real-time audience input and discussion.
This talk will be an updated talk from the Pycon 2010 version in February which i believe was well received.
Implementing Go's Select
Prototyping Go's Select in Stackless for Stackless Python with Stackless.py
Talk, 45 minutes (intermediate)
Google’s introduction of the Go language raised eyebrows in the Stackless Python community. Although very different languages, Go and Stackless Python’s concurrency model share a common ancestor: the Bell Labs family of languages (i.e., Newsqueak, Limbo). The common feature are channels: a synchronous message passing mechanism based on Tony Hoare’s Communicating Sequential Processes (CSP).
Both Go and Python have channels. However with the select language statement. Go has the ability to wait on multiple channels simultaneously. Stackless Python does not have this feature.
This talk discusses implementing a Select like feature in Stackless Python. The technique will be to prototype the feature with stackless.py – the PyPy’s project implementation of Stackless Python written in Python! Then decide what changes would be necessary to implement in Stackless Python.
Along the way, audience will learn Stackless Python basics and get a glimpse at PyPy. In the process, the audience will see how Stackless Python’s API reflects philosophical differences between Go and Stackless Python’s approach to concurrency.
PyPy 1.2: status and news
We will give an update on the state of PyPy, the Python implementation in Python.
Talk, 90 minutes (intermediate)
Part 1 - introduction and status
PyPy is a slowly emerging Python implementation written in Python. This part of the talk is going to give an introduction about the project and a description of its current status. We will focus on what it gives to Python programmers:
- What works on PyPy: - Mostly everything, as long as it works on Python 2.5 - (NEW) Most existing extension modules (written in C) work too
- The differences with the standard CPython:
- (NEW) The JIT is 100% complete and 99.9% ready to use; we will see the kind of performance that can be expected
- As usual, we will warn against some "corner case" behavioral differences in the language.
- In summary, we will see why you should (or should not) consider switching to PyPy, and for what kind of application.
Part 2 - the Just-in-Time compiler generator
PyPy now comes with an integrated JIT compiler. In this part of the talk we will see:
- more in-depth, how fast can Python code be: - With plots of various benchmarks - In comparison to the speed of regular CPython, CPython+Psyco, and of Unladen Swallow - For various algorithmic or non-algorithmic kind of code.
- How it all works:
- A reminder about tracing JITs in general
- The tracing JIT included in PyPy
- The differences between a "classical" tracing JIT (like TraceMonkey for JavaScript) and PyPy (a general tracing JIT for any language).
- Future or in-progress tasks:
- The x86-64 backend (currently only x86-32 is supported)
- A quick tour of other missing improvements
- Finally, how to use the JIT generator with your own language's interpreter (we already have a JITing Prolog interpreter :-)
Part 3 - cpyext, or how C extension modules can work in PyPy
In this part, we will talk about the new cpyext module, that allow PyPy to use the extension modules of CPython written in C. In particular:
- How it works
- What are the drawbacks, and the current status
- What are the incompatibilities, and how to solve them
How to give a shoulder massage
Help raise money for PSF and impress your girlfriend.
Talk, 45 minutes (general)
Rob is the PSF's official shoulder masseuse. He will teach you how to use shoulder massage as a PSF fund-raising tool.
Build, Packaging & Deployment
Muddle, inventing a build system
What we learned writing muddle, why we did it, and what we'd do differently.
Talk, 45 minutes (general)
Muddle is the mechanism we use to describe and manage system builds - for instance assembling a Linux based system for Internet TV on a Set Top Box. We're sure it was a good decision to write in Python, and we're fairly sure about several of the other design decisions made, but we have also some good ideas of what its deficiencies are.
This talk will explain why we felt the need to write our own solution to this problem, some of the history of the project, what its special features are (good and bad), and what we believe to be necessary to fix the problems we see with it. Since it's an Open Source project, we'll also be asking if other people want to play...
SCons, The Builder
SCons is the Pythonic way of building C, C++, Fortran, LaTeX, Java, C#, etc. systems
Tutorial, Full Day (general)
Make was a revolution but is now long in the tooth. Autotools and CMake seek to use Make, but the real future is in dynamic languages as build control. SCons is a Python framework for building and installing systems that shows that Python is a very good language for describing builds.
Custom Runtimes with PyPy
PyPy is a good base for running a Python Application without anything to install.
Talk, 45 minutes (intermediate)
How do I distribute my solution so it can be run with minimum hassle.
Bundling the source with all prerequisites in a Zip or a Source Repository can be quite useful.
In the talk I will cover * Changing command line parameters * Changing sys.path rules * Writing built-in modules * Distributing updates
Community
Why open source works
A look on what makes open source work, and what that means for copyright and patents.
Talk, 45 minutes (general)
It seems like a mystery that open source can work. Why would any rational being give away their work for free when they can charge for it? And how come an operating system build by volunteers in their free time rules the internet?
This talk uses the history of steam engines, pretty pictures and great music to explain the mechanics behind openness, and explains why open source works, and what this means for intellectual property in general.
Lightning strikes >thrice
Bugs you won't make with Python, why Python is for girls, lessens learned from old code
Talk, 45 minutes (general)
I learned that I can provide more enjoyment to the audience and myself by giving short talks. So this talk will feature at least 3 distinctive talks combined to one fast moving performance. 1. bugs you won't make in Python. While reading various programmer related blogs, magazines and worse than failures, I stumbled upon a lot of bugs and questions which do not matter if you are using Python. I will present a selected extract of those problems and why Python makes them non-problems. 2. Python is for girls - on Pycon2010 the BDFL wore a shirt with that message. I will explain WHY this is true, why Python the philosophy, Python the community and Python the language is a great choice for female programmers aka girls. 3. While renovating some code from the beginning of my Python time, I stumbled upon some wrong learnings. This talk will point them out, and also look at possible causes beyond my noobness at that time: what can we do to improve examples and explanations to accelerate good practices. 4. Pynomics - economic basics for programmers. Decisions in business context are more often based on ROI and discounted cash flow than on TCE and quicksort. This talk will give some pythonic explanation in featuring some business buzzwords to help you employ vertical synergies in enterprise business structures.
Scraperwiki
What else could it be good for?
Talk, 45 minutes (general)
There are many on-line repositories where you can upload your code, browse other people's code, and download it for editing and use. But only Scraperwiki allows you to do everything over the browser, including running and debugging.
The system is primarily intended for webscraping where the scripts are short, self-contained, specialized, and frequently out of date and broken. Scraperwiki is supposed to overcome the normally overlooked maintenance problem. This talk will explore what other things a Python Codewiki could be used for.
Python and Windows: equality?
Are Python and Windows equal citizens in each others world?
Talk, 45 minutes (general)
Python has been running natively on Microsoft Windows for over a decade and offers a host of useful tools for software development. Yet Python is rarely the tool of choice for Windows developers. Nor is Windows often the environment of choice for Python users. Why is this? And can anything be done to improve things?
Recruiting Event
'Speed' Recruiting
Other Type of Event, 60 minutes (general)
Job Seekers: You're enthusiastic Python developers, otherwise you wouldn't be here.
Recruiters: You want good Python developers, you'll find Europe's best at EuroPython!
This is an open space for Job Matching, a little like 'speed dating'.
- If you are a EuroPython Sponsor, and want to recruit Python developers, you may join is this event and give a 5-10 minute 'Lightning Talk' about your company and what it's looking for.
- if you are developer looking for a job, attend this session: if you wish, you may give a 5 minute 'Lightning Talk' about you and your skills. Following the talks, recruiters and candidates can meet and see if they want to take things further.
Note. Potential recruiters can hire a practice room for private interviews if they wish.
Arduino and Python Fun
A practical arduino workshop and introduction to Python working with Arduino
Tutorial, Full Day (general)
Arduino is a popular project for embedded interactive application development. Arduino projects - both hardware and software combined are called sketches. The aim of this workshop is to encourage programmers to "get their hands dirty" putting together various hardware components - leds, push buttons, sensors, motors, piezo buzzers and to program them up to "perform". As this is a Python conference some techniques for controlling Arduino sketches via Python scripting will also be introduced. The aim is to "bring out the tinkerer" in all of us and add a "dash of Python" for extra "fun and excitement".
Databases
Understanding FluidDB
What FluidDB is, why it was built, how it works and why you should use it.
Talk, 45 minutes (general)
FluidDB (a database written in Python) has a radical approach to creating, sharing and organising data.
This introductory talk explains:
- What FluidDB is
- Why FluidDB was written
- How FluidDB works
- Where to get involved
By the end of the talk attendees will know where to get Python client libraries and how to get started using FluidDB in their applications.
SQLAlchemy
A hands-on tutorial for intermediate to advanced SQLAlchemy users
Tutorial, Half day (intermediate)
Is SQLAlchemy a framework or a toolkit? As a batteries-included library for database interaction and object relational mapping, SQLAlchemy provides a cohesive set of features that work out of the box. While convenient and powerful as-is, SQLAlchemy is not intended as a "one size fits all" technology. Tailoring is a core feature of SQLAlchemy, from allowing DBA-provided SQL to be used in favor of generated SQL to completely bespoke object relational mapping.
This tutorial delves into customizing and tailoring SQLAlchemy to meet your needs, be they targeting a specific database and production environment, or authoring cross-platform software that adapts elegantly to different RDBMS servers. The focus will not be on mapping your RDBMS to SQLAlchemy- the documentation and mailing list are fantastic resources for that- instead, the focus is on mapping your code to SQLAlchemy and composing the toolkit into novel solutions for your requirements.
Customizing and building on a third party library can feel risky, especially when that library has not released a "1.0" milestone. In this session, we will review which parts of SQLAlchemy are core features and behaviours and which are swappable extensions or opinionated features that can be changed. You will leave the session knowing how to safely extend and reuse SQLAlchemy features in a future-proof fashion.
Building on that understanding of the core features, we will go on to explore the hooks and customization points at all levels of the package, from connection & pooling, to SQL DML and DDL generation, through object relational mapping.
This is a hands-on session with working, interactive examples to explore, so please bring a laptop loaded with Python 2.x. All other requirements will be provided on site.
Some prior experience with SQLAlchemy is highly suggested. Advanced SQL experience is not required.
Python class-PostgreSQL method
Ship code, not data - Decorators to run class method directly in PostgreSQL database.
Talk, 45 minutes (intermediate)
While modern Object-Relational Mappers (ORMs) do simplify interacting with databases, they often cause tens or even hundreds of small database requests to travel between python program and the database.
Packaging all of the data manipulation code into single method and then converting this into a database function has lots of benefits, from reducing database traffic and speeding up execution due to running closer to data to enabling advanced unlimited database scalability using pl/proxy.
While pl/proxy based "sharding" scales as well as the best noSQL based key-value stores, it retains all of standard SQL integrity guarantees (ACID) for most of your data, and enables another type of integrity (BASE) for the rest. Also, it simplifies most web development, as it lets you drop memcache - why would one need cache when real database access is just as fast, only without maintenance overhead ?
The ZODB & Me
Why you should use the ZODB as your nosql^H^H^H^H^H database
Talk, 45 minutes (intermediate)
The ZODB is a native object database that brings transparent persistence of Python objects. It provides full ACID-compatible transaction support, along with history/undo, pluggable storages, a scalable architecture and efficient support for BLOBs.
Using the ZODB requires no configuration, no glue code, and there is no gap between your database and program.
This talk will cover reasons why you may want to look at the ZODB, instructions for using the ZODB with your Python application, some example applications, and a comparison to other databases.
PostgreSQL's Python soup
There are at least 5 DBAPI compliant PostgreSQL adapters and more than one embedded python in
Talk, 45 minutes (intermediate)
A discussion about different means of accessing PostgreSQL database from Python, what are the differences and which one to use.
There is also more than one version of embedded Python language usable inside Python server.
When should you move some of your application logic into the database, and should you use PL/PythonU or some other embedded language there.
What are pros and cons of using object relational mappers vs. writing your own SQL vs. writing database functions and calling these.
When to implement connection pool in your applications database layer, and when to use external connection pool.
- PostgreSQL adapters: pgsql, psycopg, psycopg2, pygresql, ocpgdb
- Generic adapters: sqlrelay, odbc
- Object-relational mappers: SQLAlchemy, SQLObject, STORM
- Connection pools: pgpool, pgpool II, pgbouncer
Documentation, Tools & Library
A Python's DNA
Away with the complicated plug and play frameworks! Welcome Python
Talk, 45 minutes (advanced)
While developing Meresco (meresco.org) we hit the 'configuration problem':
How to create a system from components? How to configure individual components? How to specify interface dependencies? How to support data flow between components? How to write it all down? How to avoid obligatory interfaces for components? How to keep it simple?
We settled for a few simple rules:
In stead of XML, use Python to write it down. Use generators to facilitate data flow. Interfaces are methods. Dependencies are observers.
It was rather simple to create (although somewhat abstract) and our main questions were:
Will it be powerful enough? Will it remain maintainable? Will it perform?
After three years, the answers to all of these questions turned out to be Yes!
We are very pleased that the guess we took turned out right and we like to share what we did.
We also: http://meresco.com/documentation/meresco-core/2.22.9/MerescoComponentLibrary.txt (under the unhelpful name "Meresco Component Library")
JTool: Java in the Python VM
JTool: yet another Java/Python integration, this time with an Python extension using GCJ
Talk, 45 minutes (advanced)
JTool is an extension that allows Java classes to be imported and used in Python programs running in the standard Python VM.
It is used for interfacing the full text search engine Lucene and Ontotext's highly scalable triple store OWLIM.
It dynamically creates Python types for Java classes and Python objects for java objects.
It is small (1500 lines), robust, fast and flexible. It runs production in several mission-critical search engines.
See also: http://blog.meresco.com/2010/03/11/integrating-java-in-python-with-jtool/
Creating Libraries
Examining the creative process behind library construction.
Talk, 45 minutes (general)
I have been creating Python libraries for some time now. We will examine some of these libraries to learn something about the creative process behind them. What works to make a successful library? Why create libraries? What is success anyway?
PyCharm: New Python/Django IDE
Live demo of PyCharm IDE features for productive development of Python, Django and App Engine apps
Talk, 45 minutes (general)
PyCharm is a new cross-platform Python IDE from JetBrains, the makers of IntelliJ IDEA and many other development tools. The talk will start with an overview of the project status, and proceed into a live demo showing most of the product features in action.
Building a web framework IDE
Building a development environment for a Python web framework
Håkan Rosenhorn (ESN Social Software AB)
Talk, 45 minutes (intermediate)
Covering the design and implementation of a full-fledged IDE for a Python web framework. Bridging the gap between controllers and templates, managing development servers, catching errors before they happen, integrated testing and inspection management for optimizations. Discussing the Python language structure, and the effects it has on an IDE.
Programming Office with Python
Lecture on how to use COM to control & program Microsoft Office applications like Word, Excel, PowerPoint, etc
Talk, 45 minutes (intermediate)
Like it or not, we live in a world where we will interact with Win32 systems. It may be intermittent or something we have to deal with it on a daily basis, but regardless of how much exposure we face, the power of Python can be used to make our lives easier. In this session, we will explore Win32 COM Client programming using Python to control and communicate with Office applications such as Word, Excel, PowerPoint, and Outlook. COM is a service which allows Win32 applications to interact with each other. (Specifically, well-known applications such as those in Microsoft Office provide COM services, and COM client programs can be written to drive these applications.)
Traditionally, COM clients are written in VB or (Visual) C++, two very powerful but very different tools; Python is often viewed as a great substitute as it is more powerful than VB and is more expressive and less time-consuming than developing in C++.
This lecture is designed for both COM developers who want to learn how they can apply Python in their world and also for Python programmers who need to learn how to create COM clients, i.e., auto-generate Excel spreadsheets, create form letters as Word documents, make slide presentations automagically with PowerPoint, send e-mail via Outlook, etc. (We will not be discussing the principles/concepts of COM nor will we be learning about COM+, VSTO, ATL, IDL, MFC, DCOM, ADO, .NET, IronPython, etc.)
Instead, we will immerse you in COM client programming by learning how to use Python to communicate with some of the Office applications mentioned above. All of the examples used in lecture can be found in Prentice Hall's bestseller, "Core Python Programming" (2nd ed).
Education
Organise a Python code dojo!
A what, where, when and how guide to running a Python code dojo. Does NOT include free pizza & beer.
Talk, 45 minutes (general)
In this talk I aim to:
- Explain what a dojo is and why it is a great lightweight means for offline community building.
- Describe what has worked and failed in the London Python Code Dojo.
- Provide hints, tips and resources potential dojo hosts might find useful.
- Get all the attendees to think, "hey, I should organise a dojo".
Games Programming
Intro to Game Programming
Learn how to write a video game
Tutorial, Half day (beginners)
This tutorial will cover several aspects of game programming. It is designed to give the participants the information and skills they need to design a simple game and then to give them actual experience in seeing how a simple game is constructed.
At a high level I will: - give an introduction covering the elements of a successful game - present one approach for structuring your game code to keep it sane - talk about what support libraries are available - walk the participants through development of a simple game - talk through some potential further development possibilities
The game developed will cover the key game-writing skills of controlling what appears on the screen (including animation), loading resources, handling user input and simulating the environment within the game.
Participants should be familiar with Python, and have pyglet installed. I will not have time to deal with installation and compatibility issues so participants should check their laptops can run pyglet applications.
Hobbyist OpenGL: Flying High
Algorithmic generation of OpenGL models.
Talk, 45 minutes (intermediate)
Algorithmic generation of 3D geometry can produce some interesting virtual sculptures and animations.
A simple data structure for representing polyhedra can easily be converted into the arrays of vertex positions and indices that OpenGL needs, generating clean-lined retro 3D vector graphics.
Within such a framework, algorithms or generating or modifying this geometry can produce interesting shapes and effects. This is a task for which the power and flexibility of Python excels. Because the GPU is doing all the heavy lifting, we can easily view complex geometries at 60fps, all in pure Python.
Using shaders from Python is demonstrated, these can improve performance and create attractive-looking effects.
This talk builds on a previous talk 'Stretching pyglet's Wings', which described basic OpenGL applications in Python using pyglet. That talk is not a prerequisite, but it is online here: http://tartley.com/?p=378
See the wiki page linked to below for some screenshots from the talk.
UI Programming
A case for accessibility
Building for accessibility, and how it can change design and development practices
Talk, 45 minutes (intermediate)
In this talk I hope to make a case for factoring accessibility into design and development using MediaCore, which is an open source Python based video CMS, as an example.
The talk will break down as follows:
- Painting the picture - demographics on accessibility and the visually disabled.
- Understanding the problem - Showing what a day in the life of a visually disabled user is actually like. This may include a guided tour through JAWS or Zoomtext.
- Building a case for accessibility - This will discuss how we integrated many accessibility features into MediaCore (Our open source, python based, video CMS), and how we justified the investment.
- Building an accessible video CMS - We will discuss what we have leaned about accessibility, and how it has changed the way we have designed and developed interfaces. We will also discuss closed captioning, audio descriptions, accessible video players, HTML5, and the resources needed in pulling it all together.
- Dealing with Browsers - We'll cover common programming mistakes and debunk myths about how browsers handle accessibility.
Pyjamas Technology
Pyjamas Technology: Projects for both browser and desktop Widget Sets.
Talk, 90 minutes (intermediate)
Pyjamas is several projects. The projects combine to provide developers with a way to write python GUI applications once and only once, and either run them as stand-alone Desktop applications on all major desktop OSes, or compile them to javascript, to run in all major web browsers.
One of the Pyjamas projects is a stand-alone javascript compiler, which can be used with python-spidermonkey, pyv8, spidermonkey or web browser engines; another is a GUI widget set which is incredibly similar to PyGTK2 and PyQT4. By making use of browser engines, the Pyjamas UI Widget set automatically gains the benefits of HTML, HTML5, CSS and Plugins, which PyGTK and PyQT4 cannot take advantage of [without an extension which is often not cross-platform].
The talk will briefly cover the significant advances over the past year in the javascript compiler (since EP09); also there will be simple demonstrations (e.g. a game of asteroids, 2D Graphs and Google Maps) and explanations of how to interface with web engines such as Django in the most effective way.
Python RAD with Camelot
Leverage SQLAlchemy and PyQT to build desktop applications the Django way.
Talk, 45 minutes (intermediate)
Camelot uses SQLAlchemy, Elixir and PyQT to build attractive desktop applications the way Django Admin interfaces are defined. This talk will introduce Camelot, the motivations behind it and its design philosophy :
- How large datasets are handled
- How everything remains extensible
- Threading and responsiveness
Next we will walk through the application development cycle including :
- Setting up a Camelot project
- Defining models with SQLAlchemy and Elixir
- Defining table and form views
- How to extend Camelot and fall back to raw SQLAlchemy or PyQT
- Unit testing of the GUI with PyQT
- Deployment options in real life
JavaScript and MillerColumns
How and why I built a handy gadget in JavaScript with Python habits and testing.
Talk, 45 minutes (intermediate)
With Miller Columns (the iTunes interface) you can browse lots of data in a small area. Ideal for an on-screen help widget.
I've written a generic Miller Columns in JavaScript, but heavily influenced by Python (for programming style and testing).
Related projects are http://bitbucket.org/jfine/jsmod and http://bitbucket.org/jfine/python-testutil.
Silver bullets for the web
Case study of a Silverlight business application accomplished with IronPython on a tight schedule
Talk, 45 minutes (general)
During the last year our company developed a Silverlight business application for a new customer.
Without IronPython it would not have been possible to write this application within the given timeframe and budget. In the presentation I would like to talk about our development environment (Mono on Mac) the early adopter problems, some tricky programming problems, the changes in IronPython and Silverlight during the development period and our current approach to IronPython/Silverlight (in the meantime we already have built two more applications based on IronPython/Silverlight).
The perspective of the presentation will be mainly from the manager's point of view. It is designed to show managers and developers the benefits of IronPython-Silverlight for business applications.
Python Language
How Import Works
How import goes from a syntactic statement to giving your back a module
Talk, 45 minutes (beginners)
Python's import statement plays a pivotal role in any program that does any serious work. Because of this it is important to understand how it works to be able to use it properly and to its full extent.
This talk will cover as much detail as 60 minutes will allow about how the import statement works. Covering everything from how the import statement is really syntactic sugar for a function call down to how Python actually imports bytecode, as much of the process will be discussed as possible. And time permitting, a discussion of how to change the semantics of import to add useful features.
Robust Python Programs
Common problems and their remedies in beginners' code
Talk, 45 minutes (beginners)
Though Python is easy to learn and gives quick results, especially programmers who start with Python or use it only occasionally sometimes write error-prone or cumbersome code. This talk shows some of these problems and how to avoid them.
A few of the recurring problem areas are the indentation of Python code (though still less often than one might think), the usage of exceptions, exec/eval and the dangers of os.system.
Before discussing the problems themselves, the talk explains some features of Python which may result in faulty code. Probably the most important of these features is that Python copies objects only on explicit requests but otherwise just changes bindings to names or other objects. If this sounds incomprehensible, this talk is for you. :-)
Idiomatic Python
Python tips, tricks, and idioms
Talk, 45 minutes (general)
Using syntax well: slices, tuple unpacking, for-else, for-break. Take advantage of language dynamics: introspection, bound methods, and getattr() Non-java python: duck-typing, abstract base classes, easier-to-ask-forgiveness, and super(). Using iteration as glue: iterator pipelines, itertools, and generators. Higher-level python: set(), sorted(), heapq, etc.
Test Driven Development and Good Design
A coding dojo where we will teach and learn about TDD and good design.
Tutorial, Half day (general)
In this session we'll be learning about the process of writing tests before code called "Test Driven Development" (TDD). Practictitioners of this approach often report that it helps them produce better designed code. It certainly seems to produce code with better test coverage. In this session we will learn about TDD via a prepared Kata demonstration, a Randori exercise, and by examining some code that was written this way. (see http://codingdojo.org for more information about Katas and Randori). The aim of the session is to help you learn to write code with better tests and a better design.
The magical new float repr
The new float repr algorithm in Python 3.x and Python 2.7: what, why and how.
Talk, 45 minutes (general)
Anyone who's played with floats at the Python interpreter will have seen output like this:
>>> 0.1 0.10000000000000001 >>> 6.0/20. 0.29999999999999999
In Python 3.x and Python 2.7, a new method is used for computing the repr of a float, giving the following rather friendlier results:
>>> 0.1 0.1 >>> 6.0/20. 0.3
This seemingly innocent change involved adding over four thousand lines of code to the Python code base and replumbing all of Python's float-to-string and string-to-float conversions. It gives a host of obvious and not-so-obvious benefits.
In this talk I'll explain exactly what changed, why the change is a Good Thing (no, we didn't do this just to gratuitously break everyone's doctests!), and, time permitting, how the new float repr was implemented.
The Development Process of Python
Behind the scenes of CPython's development process
Talk, 45 minutes (general)
Python is an open source language, where everyone can contribute, but have you actually thought about working on it and making it even better? During the last two years I contributed to Python first as a normal user and now as a core developer and with this talk I want to unveil what happens "behind the scenes".
I will talk about:
- The tools used;
- The workflow;
- The community;
- The structure of CPython;
- How the two main branches (Python 2.x and Python 3.x) are maintained;
- What will change with the switch from SVN to Mercurial and with the release of Python 2.7.
If you are just curious or if you want to know how Python evolves, this is your chance.
Bringing OCCAM to Python
Introducing python-csp, which makes parallel and concurrent Python just as easy as sequential code
Talk, 45 minutes (intermediate)
python-csp is a new(ish) library which brings the powers of OCCAM-like high-level concurrency and parallelism to Python. python-csp makes writing concurrent code just as easy as sequential code and makes it impossible to generate race hazards.
The library comes with a number of tools to make it easy to construct and test correct code, including a customised shell with extra documentation, specialised tracers (for debugging) and unit testing frameworks. A variant of the library is also available for Jython.
This talk will introduce the main features of python-csp with a number of realistic(ish) examples, including a web server and boids animation.
Python Foundation Class
An Introduction to Programming with Python
Tutorial, Full Day (beginners)
If you are a programmer new to Python, or if you have 'picked it up', this tutorial will give you a solid foundation for the future.
The tutorial will start by getting to know the Python interpreter and taking a look at Python's introspective features, moving onto data types, sequences and dictionaries. This will be followed by functions, classes and modules and by the end of the day you will know how to develop your Python knowledge further.
Bring your laptop and get to know the Python interpreter! If you haven't got a laptop, let us know and we may be able to arrange a laptop loan (no promises).
Intro to Functional Programming
Programming in Python with a functional mindset
Talk, 45 minutes (intermediate)
This is an introductory talk to Functional Programming (FP), with examples in Python and a few other languages. The talk focus on the basics of FP, such as immutability, recursion and side effects control, but it does not touch advanced concepts like monads or combinators.
My interest is to discuss the lessons learned from FP, even when working primarily with a language (Python) which is not functional. In particular, I want to emphasize FP and unit testing are essentially telling us the same lessons; moreover, I want to show how knowledge of FP helped me a lot in SQL programming.
Mobile Computing
Mobi: a mobile user agent lib
WSGI components analyze incoming user agents, inform mobile services, respond with apt presentation
Talk, 45 minutes (general)
Mobi is a set of WSGI components that interact between a webserver and applications that serve mobile data. Mobi reads the user agent header in web requests. If it's a mobile UA it gets categorized into one of three cellphone types (following MIT's model). If the request is bound for a service that doesn't handle presentation, e.g. LDAP, Mobi packages the content in an appropriate skin and provides navigation. For requests going to an application that does do presentation the cellphone category is added to the request and the receiving application then decides how to present its content.
The talk will include a demo of an online Mobi/LDAP integration, and a brief overview of the presentation handling.
Multimedia
The MediaCore Video CMS & Marketing an Open Source Web App (was YouTube 4 Blind)
How MediaCore will change how you display video and podcasts on your site
Talk, 45 minutes (general)
This talk will introduce MediaCore, a new Python based (open source) video content management system... with a twist. It aims to be the first video platform accessible to the blind/deaf and visually impaired.
The talk will provide developers, designers, and marketers with an understanding of what MediaCore is, how they might use it, and how it is being used currently.
The talk will cover a basic introduction to installing MediaCore, how it was developed, it's mission and goals, and an interesting segment on how MediaCore aims to do open source marketing in a different way.
For more information on the project please see: http://getmediacore.com
Network
Deferred Gratification
Patterns of asynchronous flow of control with Twisted deferreds
Talk, 45 minutes (advanced)
An indicator of power in an abstraction is the extent to which its building blocks alone can be combined to elegantly solve more complex problems, i.e., without the need for additional mechanisms or ugly hacks. Lisp and the Python itertools module are good examples. When we collectively discover how abstractions can be broadly applied, especially in ways that were initially non-obvious, it's often a strong sign that the abstraction has somehow neatly managed to capture the essence of something important.
This talk will illustrate how Twisted's deferred class falls squarely into this category. A Twisted deferred, which arranges to process a result that will become available in the future, implements an idea that dates from the mid-1970s. The design and implementation of Twisted's deferreds is minimal and elegant. I will show how to use and combine deferreds and callbacks to produce surprisingly simple and robust solutions to flow of control problems in an asynchronous environment. Although these solutions can be challenging to understand, they require nothing more than a good understanding of the deferred class, knowledge of basic Python, and some comfort in thinking about programming in terms of processing asynchronous events.
Adapting libraries to Twisted
How to "Twistify" an existing library and use it with Twisted seamlessly
Talk, 45 minutes (intermediate)
A major reason for not adopting Twisted is that many 3rd party libraries don't fit well in the Twisted ecosystem due to its constraints regarding blocking I/O and threading.
Instead of rewriting them from scratch, a more pragmatic approach might be taken: work with "upstream" to integrate Twisted into their project.
In this talk we'll see several real-world examples of how we at Fluidinfo have successfully ported synchronous blocking libraries to Twisted and released them as Free Software/Open Source:
- pure Python libraries with blocking constructs, replaced with its Twisted counterparts: Qpid/txAMQP
- pure Python libraries that use blocking synchronous network I/O: Avro, Boto
- mixed Python/C libraries: Thrift
- pure C libraries with their own event loop: Zookeeper
I hope that by following these real examples, programmers will learn the intricacies of Twisted and spread its use.
Python and the IMAP protocol
How to talk politely to mail servers
Talk, 45 minutes (beginners)
The IMAP (Internet Message Access Protocol) protocol is a widely used protocol to access e-mail on a remote server. IMAP mailboxes can be managed by multiple clients in a synchronized way. This talk will give an overview of what can be done in Python with the IMAP protocol.
First, a brief overview of the protocol itself will be given: the basic commands to list, retrieve and manage messages within a mailbox, as well as an explanation of the best practices for retrieving email in a harmless way to mail servers.
Then, I will explain how to use the imaplib module of the standard library, which is a low-level IMAP client that maps IMAP commands to python methods.
Afterwards I will present IMAPClient, a third-party module built on top of imaplib that provides a more pythonic interface dealing with native Python types instead of raw IMAP data.
I will conclude by giving examples of how to extend the imaplib module to support additional commands such as IDLE for push mail or Gmail's recently released OAUTH authentication system.
gevent network library
Using lightweight threads to write simpler network applications
Talk, 45 minutes (intermediate)
This talk introduces gevent network library.
First we'll briefly look at the traditional ways to do network programming in Python.
We will then see how greenlet/libevent-based gevent lets you write clean concurrent applications that do not require callback chains and state machines yet can handle thousands of connections efficiently. Comparing to real OS threads, coroutines are simpler to use, do not require synchronization and use orders of magnitude less memory.
We'll then learn gevent API (which is very simple because it reuses lots of concepts and interfaces from the standard library).
In conclusion we will cover some real world examples.
Opening Keynote
Welcome to Birmingham for EuroPython 2010.
Plenary Event (whole conference), 45 minutes (general)
Meet the team behind EuroPython and your fellow delegates, and find out essential information and latest changes. Followed by Russel Winder's keynote.
Meet and Greet Partners
Meet and Greet Partners at Conference Reception Desk
Partner Programme, 60 minutes (general)
Meet and Greet Partners at Conference Reception Desk
The Birmingham City Centre Stroll
A leisurely stroll around the main sights of Birmingham City Centre
Partner Programme, 90 minutes (general)
A leisurely stroll around the main sights of Birmingham City Centre
BBC @ The Mailbox
A visit to see BBC's studios in The Mailbox. We will be able to see programmes being made. We will have the opportunity to try reading the news or presenting a weather report.
Partner Programme, 60 minutes (general)
A visit to see BBC's studios in The Mailbox. We will be able to see programmes being made. We will have the opportunity to try reading the news or presenting a weather report.
The Mailbox
Visit to The Mailbox - 'Birmingham’s premier shopping and lifestyle location with exclusive stores, restaurants, café bars and hotels. It is the ultimate destination for designer shopping in the Midlands with international brands as well as chic salons & spas in one central Birmingham location'
Partner Programme, 45 minutes (general)
Visit to The Mailbox - 'Birmingham’s premier shopping and lifestyle location with exclusive stores, restaurants, café bars and hotels. It is the ultimate destination for designer shopping in the Midlands with international brands as well as chic salons & spas in one central Birmingham location'
Museum and Art Gallery
It is 125 years since Birmingham Museum and Art Gallery first opened its doors beneath the clock tower on Chamberlain Square. Inside you will find everything from Renaissance masterpieces to 9,000-year-old Middle Eastern treasures. Famous for its Pre-Raphaelite paintings. You can see art and objects spanning seven centuries of European and World history and culture. Find out more about Birmingham’s history or see the Egyptian mummies.
Partner Programme, Half day (general)
It is 125 years since Birmingham Museum and Art Gallery first opened its doors beneath the clock tower on Chamberlain Square. Inside you will find everything from Renaissance masterpieces to 9,000-year-old Middle Eastern treasures. Famous for its Pre-Raphaelite paintings. You can see art and objects spanning seven centuries of European and World history and culture. Find out more about Birmingham’s history or see the Egyptian mummies.
Canal trip
See parts of Birmingham that you can't see from any other vantage point. Birmingham's canals are the most extensive in Europe and have recently been renovated to be a pleasant leisure facility.
Partner Programme, 90 minutes (general)
See parts of Birmingham that you can't see from any other vantage point. Birmingham's canals are the most extensive in Europe and have recently been renovated to be a pleasant leisure facility.
Lunch at International Convention Centre
Lunch at International Convention Centre
Partner Programme, 90 minutes (general)
Lunch at International Convention Centre
Rhubarb at Custard Factory
The Rhubarb Radio Station is a community Internet radio station based at the Custard Factory.
Partner Programme, 90 minutes (general)
The Rhubarb Radio Station is a community Internet radio station based at the Custard Factory.
Jewellery Museum
When the proprietors of the Smith & Pepper jewellery manufacturing firm decided to retire in 1981 they ceased trading and locked the door, unaware they would be leaving a time capsule for future generations.
Tools were left strewn on benches; grubby overalls were hung on the coat hooks; and dirty teacups were abandoned alongside jars of marmite and jam on the shelf.
In the eighty years before its closure little changed with the working practices or equipment used within the family-owned business. Even the décor had more in common with early 20th century trends than a thriving business in the early 1980s.
Today the factory is a remarkable museum, which tells the story of the Jewellery Quarter and Birmingham’s renowned jewellery and metalworking heritage.
There are live demonstrations of traditional jewellery-making skills and visitors can experience of what it was like to work in this noisy and busy workshop.
Partner Programme, 90 minutes (general)
Highlights include:
- Visit to the Smith & Pepper factory by guided tour. Allow one hour for guided tour. Last tour approximately one hour before closing. The maximum number of people on each tour is 18.
- The museum shop, which stocks a range of locally made designer-maker jewellery
- Live demonstrations at the jeweller’s bench showing how the Smith & Pepper bangle was made
- The vast array of original tools, stamps and machinery that remains inside the factory
Lunch in Jewellery Quarter
Lunch in Jewellery Quarter
Partner Programme, 90 minutes (general)
Lunch in Jewellery Quarter
Pen Museum and Jewellery Shops
Set in the atmosphere of a former Victorian pen factory, the Pen Room Museum is dedicated to preserving and promoting the legacy of this trade. There is ongoing research into the social, historical and technical aspects of the trade and also the Jewellery Quarter itself. The museum has assisted people tracing their genealogy and is keen to hear from anybody who has had connections with the trade.
Whilst in the Quarter, shopping is a must – browse through over 100 specialist jewellery retailers for classic pieces and beautiful handcrafted jewellery, or why not commission your own design? Jewellery, clocks and watches are competitively priced and with its many craftsmen and contemporary designer makers, you’re sure to find something special in Birmingham’s Jewellery Quarter.
Partner Programme, Half day (general)
During the 19th Century, 75% of everything written in the world was with a ‘Birmingham’ pen. Birmingham was at the forefront of this trade until it declined in the 1950’s with the invention of the biro and fountain pen. At one time there were about 100 factories in the Jewellery Quarter area. The development of the steel pen reduced the cost of writing and enabled the spread of literacy throughout the world.
Whilst in the Quarter, shopping is a must – browse through over 100 specialist jewellery retailers for classic pieces and beautiful handcrafted jewellery, or why not commission your own design? Jewellery, clocks and watches are competitively priced and with its many craftsmen and contemporary designer makers, you’re sure to find something special in Birmingham’s Jewellery Quarter.
Python Language Summit
Meeting of top minds and anyone who we drag in off the street to plan world domination by Python and allied forces.
Meeting, Full Day (general)
Meeting of top minds and anyone who we drag in off the street to plan world domination by Python and allied forces.
OpenID
OpenID
Talk, 45 minutes (intermediate)
See the white board by the information desk
Python 3
Porting to Python 3
A look at the strategies for porting to Python 3, and a quick look of the most common problems.
Talk, 45 minutes (general)
This talk is split into two parts. The first will look at the different options in how to handle Python 3 porting. Do you need to support Python 2, or just port once? Should your code run unmodified or via 2to3, etc.
The second part looks at the most common problems in porting, and how you can solve them.
Science
Maths - with No Programming
Want to solve maths problems with as little as possible programming - here's how to with python
Talk, 45 minutes (general)
For scientists, mathematicians, engineers and maths people who generally want to perform some mathematical calculations but do not want to have to learn to much (if any) programming. It is also suitable to software engineers who support a individual/team or teams of the above people.
The talk will cover the following:
- How to set up (in theory) your work environment to achieve this.
- How to evolve your method(s).
- Why Python is good for this.
- An example of how this can be done supported commercially in Python.
If you use numpy or scipy, then this will be of use to you.
Regarding re, regex, and re2
Roundup of regular expression engines for Python
Talk, 45 minutes (intermediate)
The re module in the standard library, lacks some features found in Perl, grep and other regular expression implementations. This talk will introduce two alternatives:
- regex - A re-implementation of re with better Unicode behaviour, multithreading, POSIX character classes and other additions.
- re2 - An fast regular expression engine based on automata theory, rather than backtracking. Expressions run in linear time, rather than exponentional.
The talk shall compare the engines, showing when each should be used or avoided, and the difference this can make.
SHOGUN
A Large Scale Machine Learning Toolbox
Talk, 45 minutes (intermediate)
We have developed the SHOGUN machine learning toolbox, which features algorithms for hidden markov models, regression and classification problems. SHOGUN's focus is on Support Vector Machines (SVMs), but it also implements a number of linear methods like Linear Discriminant Analysis, Linear Programming Machines and Perceptrons.
SVMs are a popular machine learning technique that have become increasingly mature during the last decade, often providing state-of-the-art performance while maintaining the ability to cope with large amounts of potentially diverse training examples.
A central feature of SVMs is its ability to employ kernels, which allows to encapsulate the input domain from the learning algorithm, allowing to incorporate arbitrary objects such as real vectors, strings or graphs into the learning problem.
SHOGUN provides a generic SVM interface enabling the choice between fifteen different SVM optimizers as back-ends, among them the state of the art LibSVM and SVMlight, SVMOcas or Liblinear. These SVMs can be easily combined with more than 35 different kernel functions (see http://www.shogun-toolbox.org/doc).
All of SHOGUN's core functions are encapsulated in a library libshogun written in C++ for maximal performance. Built around SHOGUN's core we provide two types of python interfaces: A modular interface created with SWIG (The Simplified Wrapper and Interface Generator) and a static interface that conveniently interfaces with python. Note that in addition to the python interfaces, SHOGUN provides bindings from C++ to other languages, such as R, Octave and Matlab with the exact same syntax and functionality.
A central design goal of SHOGUN was to enable large-scale learning. Therefore, we implemented auxiliary routines that allow faster computation of combinations of kernel elements that lead to significant speedups during training and evaluation enabling us to solve several large-scale learning problems in biological sequence analysis involving millions of sequences. Furthermore, linear SVMs can be efficiently trained by computing feature spaces on-the-fly, even allowing to mix sparse, dense and other data types.
For some learning problems, data sets are available for several input domains (e.g. gene expression measurements and blood measurements for each patient), which can be incorporated into a learning problem by using several kernels. Often, however, it is unclear how much discriminative information each kernel provides. As a remedy, Multiple Kernel Learning (MKL) provides the means to learn a weighting for each of the used kernels. State-of-the-art algorithms for MKL are implemented in SHOGUN. Additionally, SHOGUN provides algorithms for multi-class problems and multi-task learning.
Finally, we would like to point out that SHOGUN has successfully been used in a range of problems from Computational Biology, such as gene finding (mGene; http://mgene.org), splice-site prediction (ASP; http://www.fml.tuebingen.mpg.de/raetsch/suppl/splice), promoter recognition (ARTS; http://www.fml.tuebingen.mpg.de/raetsch/suppl/arts), Transcription-factor binding prediction (KIRMES; http://www.fml.tuebingen.mpg.de/raetsch/suppl/kirmes), protein sub-cellular localization and others.
In the proposed talk, we will give an introduction to the core functionality of SHOGUN, such as training SVMs with different solvers and kernels, introduce some of its more recent features, such as Multiple Kernel Learning and Multitask Learning and finally give a few illustrative practical examples from Computational Biology.
Python and Machine Learning
An overview of Python tools available for designing algorithms that evolve behaviours
Talk, 45 minutes (intermediate)
A major focus of machine learning research is to automatically learn to recognize complex patterns and make intelligent decisions based on data; the difficulty lies in the fact that the set of all possible behaviors given all possible inputs is too complex to describe generally in programming languages, so that in effect programs must automatically describe programs.
Python is great for brainstorming and trying out new ideas. I will give an overview of the tools that are available to date that can assist in rapid prototyping and design of machine learning programs in Python.
Testing
Visualizing Software Quality
Improving efficiency of testing initiatives proves difficult in big software projects (>> 1 man year
Talk, 45 minutes (intermediate)
We are facing a software crisis. When software projects grow big (multi person, multi man year) they get difficult to maintain which leads to high maintenance efforts, code duplication, bugs, and related problems. This leads to very limited software lifecycles in areas where software evolves rapidly. For example in an industry setting the software usually will be re-implemented every 3-5 years. This is a huge waste of resources but currently the only foolproof strategy.
Quality initiatives could make a difference but they always live on a short budget. And since testing is never complete it is desired to drive testing efforts to areas that could benefit the most.
The root cause of the software crisis is that we can not see, or touch the software like we can see or touch the work products of other engineering disciplines like in construction or mechanics. Also the quality of the end product is not easily accessible like in those of other disciplines. E.g. you instantly see whether a car misses the bumper, a door or the windshield.
What if we could make the quality of the software visible? This could help us to drive testing efforts or decide if we are ready for go life. The talk will provide in depth insights on how to visualize different aspects of software quality (reference to relevant literature is given University of Maryland, Professor Edward Tufte et al.).
The talk will feature a demonstration of software quality visualization of the Mozilla Firefox browser. The qa-visualizer first version is based on several open source projects (CouchDb, Python plus some extensions, JavaScript, YUI3).
New *and* Improved
Coming changes to unittest in Python 2.7 & 3.2
Talk, 45 minutes (intermediate)
In Python 2.7 and 3.2 a whole bunch of improvements to unittest will arrive. unittest is the Python standard library testing framework and for several years it has languished whilst other Python testing frameworks have innovated. Some of the best innovations have made their way into unittest which has had quite a renovation.
This talk will go through the major changes, like the new assert methods, test discovery and the load_tests protocol, and also explain how they can be used with earlier versions of Python.
Testing Panel
We have assembled a group of Python testing experts for you to quiz or harangue with all your difficult testing questions.
Meeting, 45 minutes (general)
Panel members will include:
- Raymond Hettinger (Python core developer)
- Jason Huggins (Creator of Selenium, web testing tool)
- Michael Foord (maintainer of unittest and creator of mock)
- Holger Krekel (creator of py.test)
- Geoff Bache (creator of TextTest and PyUseCase)
- Mark Ramm (Turbogears BDFL)
Expect plenty of vigorous debate on Python testing tools and techniques.
The panel will be expertly chaired by experienced Python developer Ali Afshar. If you have questions you would like the panel to answer you can add them to google moderator, or vote for (or against) questions already there:
What I Learned at PyCon
Lessons learned over a year of functional web testing at Idealist.org
Talk, 45 minutes (general)
Have you ever attended a presentation that made you think "Wow, this approach could be exactly what I need- I'm going to implement this right now!"?
This is the tale of a development team that saw just such a presentation and recollects their real world experiences implementing and evolving the techniques over a year, for better or for worse.
This whirlwind talk will cover:
- Basics of functional web testing
- Patterns for testing and authoring tests
- Tips for extending the impact of a small development team
- Tools, including Selenium and lxml
Python & Selenium Testing
Using Python and Selenium for parallel, cross-browser testing in the cloud
Talk, 45 minutes (intermediate)
Selenium is the emerging standard for functional web testing. It is easy to get started with a simple Firefox add-in that records a session and writes out the actions in an editable Python script.
This talk walks through an example of how to build a series of tests, modify them to use multiple input datasets and run the tests in multiple browsers. The tools are open source and have extensive Python bindings.
We also explore the Sauce Labs extensions to Selenium that improve usability and reliability. We modify our script to run the tests in parallel in the Sauce cloud and then instantly review the results in a recorded video.
Afterwards, we discuss the upcoming Selenium 2 release which incorporates web-driver and frees the tests from the Javascript sandbox.
Walk away with an understanding of how to test web applications using Python, Selenium, and Sauce Labs extensions.
Good Tests, Bad Tests
How to write more of the former, and fewer of the latter
Talk, 45 minutes (intermediate)
It's widely accepted that testing your code is, in principle, a Good Thing; much like eating your greens and getting regular exercise. However -- just as novice chefs might overcook their cabbage -- many developers' first tests end up mushy, smelly, and generally unappealing. Worse: ill-prepared cabbage only smells for a day or so, but bad tests can stink up your codebase forever.
Certainly, the first tests I wrote were appalling. However, after four years of full-time test driven development, my tests have come to suck significantly less. This is largely because I've learned to recognise many of my mistakes as I make them, and act immediately to mitigate their long-term effects; in this talk, I hope to teach you to do the same.
If you're currently suffering from bad tests, this talk may help you improve them; if you tend to avoid testing because of bad experiences, it may help change your mind; and even if you've just been earnestly intending to write some tests sometime, it'll make them that much better when you get around to it.
Testing in Python with py.test
Overview on testing approaches and news from py.test
Talk, 45 minutes (beginners)
I'll start with an overview of testing approaches and current tools for testing with Python. We then look into new features and new plugins for py.test which has been inspiring changes in the Python testing world for a number of years now. I'll highlight how py.test fits a growing number of needs, for example:
- Functional and system testing
- Interaction with Non-Python (programmers)
- Python coverage testing
- testing compatibility with Python3
- run tests written for nose or unittest
- ad-hoc distribute tests to local or remote Python environments
- run javascript unit-tests in real browsers
I'll conclude with emerging features regarding testing-in-the-cloud and my thoughts on test tool convergence.
py.test I - rapid easy testing
Introduction to basic testing principles and py.test usage
Tutorial, Half day (beginners)
Want to learn writing tests in Python? This tutorial introduces basic practises using the popular py.test (http://pytest.org) tool. We start with an overview on testing and tools in Python and then discuss and exercise basic idioms in a step-by-step manner. We cover the basic writing, organisation and running of tests and debugging options. In the second part we discuss setup and tear-down of test state, usage and configuration of test functions arguments and introduce coverage testing. We will close with time to answer questions and discuss topics from the participants.
py.test II - advanced configs
Parametrization and distribution techniques, best practises
Tutorial, Half day (intermediate)
Want to learn about project-specific test parametrization and distributing tests to local and remote processes? How to create advanced and feature rich test environments for larger projects? In this tutorial we show and discuss best practises. We'll exercise writing of project-specific extensions and walk through some interesting helpers and extensions to grow your testing tool box. We also play with ad-hoc distributing tests across CPUs and platforms.
I'd like to leave room to discuss and work on challenges that participants bring with them (please e-mail any related ideas to me ahead of the tutorial so i can prepare - e.g. to holger.krekel at gmail com).
I recommend newcomers to py.test visit the "pytest-I" tutorial to make the most use out of the more advanced topics discussed in pytest-II.
Hands-on testing with TextTest
This session aims to present a technique and a tool for automating maintainable black-box tests.
Tutorial, Half day (general)
Testing a program by comparing text files written by the current run with those from previous runs is an old idea, but one which has fallen out of fashion. This talk aims to rehabilitate it as an agile technique and present a suitable tool, TextTest. We aim to show that there are applications where testing in this way has major advantages, and examine the advantages and disadvantages in a more general setting.
TextTest is a standalone tool and an extensible Python framework, and while it can test programs written in any language, it is especially suited to the dynamic nature of Python and to testing small command-line scripts where Python is also at home.
We will present the tool for the first half-hour or so and then get people to install it on their laptops and help them through a series of toy programs to test with it. (Starting with Hello World and getting progressively more complicated). We will cover testing scripts, legacy systems and possibly PyGTK UIs depending on how well people get on. We will finish with a "retrospective" where there will be an open discussion on what we have learned.
Attendees should be technically capable and reasonably familiar with Python. They should bring a laptop, with Python/PyGTK installed following the instructions given at http://www.texttest.org/index.php?page=documentation_trunk&n=install_texttest .
TextTest: Text-based Acceptance testing
This session aims to present a technique and a tool for automating maintainable black-box tests
Talk, 45 minutes (general)
Testing a program by comparing text files written by the current run with those from previous runs is an old idea, but one which has fallen out of fashion. This talk aims to rehabilitate it as an agile technique and present a suitable tool, TextTest. We aim to show that there are applications where testing in this way has major advantages, and examine the advantages and disadvantages in a more general setting.
TextTest is a standlone tool and an extensible Python framework, and while it can test programs written in any language, it is especially suited to the dynamic nature of Python and to testing small command-line scripts where Python is also at home. There will also be a brief practical demonstration.
This talk is aimed at technical people of any experience level who are interested in techniques for testing their programs in a more black-box way than offered by doctest or unittest, i.e. specifying tests in terms of how to run the program and what to expect rather than in terms of the code itself.
PyUseCase: Testing Python GUIs
PyUseCase is an unconvential record/playback test tool for Python GUIs, currently PyGTK and Tkinter
Talk, 45 minutes (general)
PyUseCase is an unconventional GUI testing tool for PyGTK. Instead of recording GUI mechanics directly, it asks the user for descriptive names and hence builds up a "domain language" along with a "UI map file" that translates it into the current GUI layout. The point is to reduce coupling, allow very expressive tests, and ensure that GUI changes mean changing the UI map file but not all the tests. Instead of an "assertion" mechanism, it auto-generates a log of the GUI appearance and changes to it. The point is then to use that as a baseline for text-based testing, using e.g. TextTest. It also includes support for instrumenting code so that "waits" can be recorded, making it far easier for a tester to record correctly synchronized tests without having to explicitly plan for this.
PyUseCase consists of a core framework that could be extended for any rich-client Python UI (e.g. PyQT, wxPython), and specific implementations for PyGTK and Tkinter. It was presented at Europython 2009 but a lot of work has been done on it since, removing the need for instrumentation and adding support for Tkinter.
Testing HTTP Apps with Python3
Introduction to a Web app testing framework written in Python 3
Talk, 45 minutes (intermediate)
Monstrum is yet another approach to testing HTTP applications. It enables developers to record test sessions in their browsers, edit the parametrized outcome and play it back multiple times. There are a couple of unique features like automatic parametrization of variables during recording, support for a wide range of assertions to be checked during test playback and a visual test configurator/runner.
Presentation plan
- Basic concepts and design decisions.
- Features overview.
- The impact of Python 3 & how it feels like to actually develop in Py3K.
- Brief comparison with Selenium, Windmill, JMeter and Funkload.
- Demo.
Improving your skills
What are you doing to improve your coding skills?
Talk, 30 minutes (general)
Everyone needs lifelong learning and continuous improvement. I've got a few ideas and tips for what you can do. (I gave this talk at my tutorial yesterday, the one about TDD and good design.)
Web Programming
Glashammer
And now for something completely different: Glashammer web application framework
Talk, 45 minutes (intermediate)
This talk will describe the Glashammer web application framework, specifically:
- How to write a web framework without getting mercilessly flamed
- The motivation behind writing a new web framework and the limitations of the current web frameworks
- General structure of Glashammer and how it solves some of the limitations of current frameworks
- How to leverage best-of-breed libraries to do what you want without reinventing any wheels
- Extending Glashammer
- A basic Glashammer application
- Unit testing a Glashammer application
- Things that Glashammer can't do, but would be really wicked
The talk will be high-level, and maybe fun. And I promise not to be mean about Django (an honourable framework).
Caching techniques in python
Some of the pitfalls and common practices in caching python and django
Talk, 90 minutes (general)
Ideas, problems and commonly used techniques used in an effort to improve response time of your python application, specifically targeted at web applications built around django.
Talk starts with discussion of more abstract problems, common patterns of code that can lead to an error.
Then we three levels of caching, that be cache on the level of single process, whole application and whole deployment (content, media, statics and so on)
Talk ends with some time for anyone to ask a question.
Speed Thrills!
An introduction to the Repoze.BFG Framwork
Talk, 45 minutes (intermediate)
Drawing on over ten years' practical experience from across the Python web development community, Repoze.BFG represents current best practice in web application frameworks: it is quick to set up and play with; it is blazingly fast; it is extensively tested and documented; will run where you want it and it is only as big as you need it. It really does tick all the boxes.
BFG makes use of component archictecture for both speed and extensibility. This makes BFG suitable both for "simple" sites such as wikis and blogs with the component architecture providing a clear path to reliability and scalability should your application require them. One of BFG's strengths is that not to sites or applications are identical.
And, as BFG is happy to run on a relational database, Couch or Mongo DBs, the ZODB or even Google App Engine you can develop knowing that deployment is guaranteed.
The presentation will cover the core ideas behind BFG and at the end of it you might want to give it a try.
Python in the Browser
Python in the Browser with IronPython and Silverlight
Talk, 45 minutes (intermediate)
You write your server code in Python because you want to. You write your browser code in JavaScript because you have to. But with IronPython and Silverlight, you can write your browser code in Python and leave JavaScript behind.
That's what I've been doing since November last year; writing complex business applications that run in the browser in Python. In this talk we will look at what is possible, including the new “just text” model where Python code is embedded directly in HTML pages. Even if you develop on Linux or Mac, you can still take advantage of Silverlight in the browser.
Tickery, Pyjamas & FluidDB
Building Tickery using Pyjamas, with writable "social" data storage in FluidDB
Talk, 45 minutes (intermediate)
Tickery is a web application backed by FluidDB. It is written entirely in Python, which is compiled to Javascript using Pyjamas. Tickery lets you perform operations on Twitter friend sets - e.g., see who people follow in common, or who people follow that you do not. Tickery provides a simple intermediate query language, but also direct access to FluidDB's underlying query language for much more powerful search.
In this talk I will discuss the design and architecture of Tickery and life with Pyjamas, including Tickery's JSONRPC calls that are proxied to FluidDB. I'll also show how using FluidDB as the underlying database makes Tickery's data extensible - allowing arbitrary unanticipated customizations, without asking for permission - and how the new data can also be searched on using Tickery. This points to a future in which users are able to customize and personalize their digital worlds and in which users, not applications, have the last word on their own data.
web2py
bringing python web development to a larger audience
Tutorial, Half day (intermediate)
This is a tutorial on the web2py web framework. We will cover the motivations for creating web2py, it main design decisions, and overview of main features. We will emphasize differences between web2py and other frameworks (like execution vs importing, the web based IDE, the ticketing system, the GAE-friendly database abstraction layer) and some of its more standard features (routing, dispatching, MVC design, form generation, postbacks, validation, security features and internationalization). We will discuss the new plugin system.
Appstats
Appstats - RPC instrumentation and optimizations for Google App Engine
Talk, 45 minutes (intermediate)
Appstats is a pure userland library (for Python and Java) that inserts instrumentation hooks into the App Engine runtime at the interface between the runtime and services like the datastore. The collected statistics can be browsed in a rich UI which allows drilling down to various levels of detail. The talk will also discuss common optimizations to address typical findings.
Flatland Form Processing
An introduction to HTML form processing using flatland.
Talk, 45 minutes (intermediate)
Flatland is a schema-based data serialization toolkit used to convert data between structured python representations and flattened representations such as HTML forms with optional validation support.
In this talk we'll begin with a quick review of the basics of HTML form processing:
- Type-conversion and validation of incoming POST data
- Re-population of data in outgoing HTML form (eg. in case of validation errors)
- Population of model objects for persistence or other onward data processing as appropriate
Next we'll make a brief tour through a few existing form processing tools in the cheeseshop. Finally we'll make the case for using a schema-based approach and demonstrate how flatland streamlines the common steps mentioned above.
We'll close with a brief look at other areas where a similar workflow can be applied (there's more to life than HTML forms!) such as REST and JSON APIs, config file validation and more.
http://pypi.python.org/pypi/flatland
You don't use Grok
It's okay you don't use Grok. But what can you learn from it?
Talk, 45 minutes (general)
Grok is a web framework, like so many others. Grok employs some concepts and technology that may be unusual to users of other web frameworks. While Grok may not be in your future, some of ideas behind Grok might be - Grok is Zope technology, and we've been ahead of the curve before. Learn about the future! Or at least a crazy alternative present!
Real-world TDD on AppEngine
Lessons learned from building web apps on App Engine
Talk, 45 minutes (intermediate)
A talk that will walk you through my experience of trying to build an interesting web application on Google App Engine using Test Driven Development.
This talk is aimed at people who are already familiar with Python and App Engine but want to know how they can apply the techniques of TDD in this environment. The talk is focussed on sharing and improving upon the lessons I learned in the process of building and maintaining several web applications.
Taming Twisted with Generators
Taming Twisted with Generator Trampolines: An Introduction to Monocle
Talk, 45 minutes (intermediate)
The usual style of client/server programming using Twisted involves writing many callbacks and error-handlers. Sequences of events get lost in a sea of unconnected methods. The Monocle module provides a straight-forward way of consolidating event sequences and their error handlers into a single generator. The resulting code is clean, easy-to-write, and easy-to-read.
This talk walks through examples of how to write client/server logic using Monocle and then it explores how Monocle works, starting with a trampoline model using simple generators, improving the model with generators that can return values, and showing how exceptions can be cleanly wrapped into the model.
Walk away with a clear understanding of how to use Monocle and how it works.
Fun with Databases and Django
A look at more advanced database usage with Django; better queries, schema edits, and non-rel DBs
Talk, 45 minutes (intermediate)
Django has an excellent ORM, but the tutorial and your first few sites all follow the same, simple pattern.
This talk will cover the headier aspects of database interaction with Django; starting with schema changes, and covering custom filtering, raw queries, aggregates, full-text search, and even touching on non-relational databases.
Web SIG
Python on the Web - Special Interest Group
Talk, 45 minutes (intermediate)
Open circle discussion about Django, web frameworks, add ons and anything else you want to mention. Plus the opportunity to 'show and tell' your website or your code.
Idiomatic Python: The Final Chapter
Python tips, tricks, and idioms. This time we take no prisoners!
Talk, 45 minutes (intermediate)
Part 2 of the talk, some slice of the following:
Using syntax well: slices, tuple unpacking, for-else, for-break. Take advantage of language dynamics: introspection, bound methods, and getattr() Non-java python: duck-typing, abstract base classes, easier-to-ask-forgiveness, and super(). Using iteration as glue: iterator pipelines, itertools, and generators. Higher-level python: set(), sorted(), heapq, etc.
Advanced Django ORM techniques
Making more efficient use of the object-relational mapper
Talk, 45 minutes (intermediate)
Django's ORM is extremely powerful, allowing you to manage your data without ever going near a line of SQL and hiding a multitude of complexities. But its power can sometimes be a curse rather than a blessing, multiplying queries without your knowledge and bringing your database to its knees.
In this session I explain what's going on behind the scenes and present some techniques to make your ORM use more efficient, showing how to monitor what's going on and how to better deal with relationships, indexes and more.
WSGI from Start to Finish
How to use the power of WSGI to solve problems your framework cannot solve
Tutorial, Half day (advanced)
Web Application Frameworks are so popular because they take care of all the common (and boring) routines required to run applications, and expose a high level interface which hides a great deal of the complexity.
But some problems are better solved at the point of HTTP request and response processing rather than using the mechanisms provided by a framework. Sometimes this may even be the only option.
The low-level infrastructure to generate an HTTP response to an HTTP request in Python applications are defined by the Web Server Gateway Interface (WSGI), which defines the communication between the server gateway (e.g., mod_wsgi) and the Python framework.
This tutorial outlines the theory and discusses practical approaches to solve real-world problems in development and deployment using WSGI. Participants will learn to write (complex) WSGI applications and middleware, integrate WSGI solutions in their frameworks and identify the best deployment method for their applications.
Zope Components for the Win
What the Zope Component Architecture is and how we used it to solve the consultingware problem
Talk, 45 minutes (intermediate)
There are companies that customise their software product to multiple clients. Each client uses a separate configuration that has to be managed by the developers. The individual customisations must be kept from interfering with each other. As the software evolves, each configuration has to be kept in a working state. Let's call this the consultingware problem.
In this talk I will quickly introduce the Zope Component Architecture and will demonstrate how we used it to address the consultingware problem on a particular business application. I will also review some alternative ways to deal with the same problem.
Zope Component Architecture is one of the most widely used products of the Zope community. In short, it is a language extension that provides a uniform way to implement pluggability and software configuration.
Look Again at the ZCA
As Python applications become larger, how the Zope Component Architecture will help you
Talk, 45 minutes (intermediate)
One of the major upheavals of Zope 3 was the breaking up of what had been a monolithic architecture into smaller interacting pieces, many of which are usable and valuable outside Zope. One of the core features of Zope is it's component architecture, the ZCA, and the supporting infrastructure. This is now available for use outside Zope; this talk will explain the fundamentals of the ZCA and why you might want to use it.
As programs get bigger, the ability to componentise them is a great help in raising the level of abstraction and thus reducing the overall complexity of the application. Python is now moving into the enterprise world with a vengeance, a world noted for its complex and changing requirements. The features of the ZCA slot well into this arena, as you can swap components as business logic changes and more easily manage your codebase.
Local user group SIG
Running a local Python Group
Talk, 45 minutes (general)
Want to run or join a local user group in your area? Members of Python West Midlands will lead the session, share their experience and try to match up people from the same areas.
Intro to Google App Engine
Lecture & workshop introducing attendees to Google App Engine
Tutorial, Half day (intermediate)
Google App Engine is a unique hosting platform that lets you build applications and run them in Google's data centers using the massive global infrastructure built to run the Internet's most powerful company. App Engine offers a development environment that uses familiar technologies (Java and Python) and provides a powerful and robust set of APIs to users while maintaining security and independence from other apps running in the cloud. It is always free to get started so you can try it out with no risk, and if you need additional computing resources, you can purchase additional computing resources beyond the free quota limits. If you enable billing and trust us with your credit card, we will extend your free quotas even further; you won't get charged until you exceed those extended quotas. Scale your application to millions of users and pay only for what you use at competitive market pricing.
In the first part of this session, you will learn about Cloud Computing and where Google App Engine fits into this "new" paradigm. The presentation will cover the following topics:
- What is Cloud Computing?
- Challenges of building (web) applications
- What is Google App Engine?
- App Engine Components
- App Engine Services and APIs
- Some App Engine Users/Case Studies
After the approximately one-hour lecture, we'll show you how to create applications that run on App Engine by building a simple but real web application from the ground up via a hand-on coding laboratory. Although based on the online tutorial, this codelab goes up and beyond what's in the documentation: you will get a more detailed step-by-step instructions to replicate that example as well as have the opportunity to extend your application with some of the newer APIs that come with App Engine. Although the codelab is available for both Java and Python users, the on-screen demonstration will be executed in Python, as it has a lower barrier of entry and takes less time to develop and understand, regardless of your core competency as this is an already time-constrained session. Users more comfortable with Java always have the option of using it instead of Python via the parallel codelab. The codelab will (time-permitting) cover as many of these App Engine features & APIs as possible:
- Review setup and launchers
- Basic "Hello World" app
- Processing GET requests
- Web forms and processing POST requests
- Datastore: saving app data to the cloud
- Users service: authentication via Google Accounts
- Web templating (with Django)
- Static file support
- Caching with Memcache service
- Template inheritance
- Sending email (receiving also possible)
- XMPP service: chat/instant messaging (IM)
- Creating log entries and how to find them
JavaScript for Pythonistas
For those who know Python and want to learn JavaScript
Tutorial, Half day (intermediate)
Although both dynamic languages, JavaScript and Python are very different. For example, their object and inheritance models are very different.
We will cover these fundamental differences and, if there is time, some mechanisms for classes, modules and testing in JavaScript.
Real Time Websites with Python
Serving real time updating web pages with Python
Talk, 45 minutes (intermediate)
When you want a web page to be automatically updated you need to establish streaming HTTP connections. That kills the performance in traditional web servers.
In the talk I will look at how to build the server side in a way that can handle a high load of concurrent requests.
Web/mobile templating in Silva
Provide authors with extended layout options, maintain web and mobile variants of the same content
Talk, 45 minutes (intermediate)
The Silva CMS has new innovations in templating for web and mobile content presentation. This talk will describe how the hierarchy of templates interact, how authors can have a greater degree of freedom for content layout, and how developers can provide and customize templates for variation in their sites. The system allows users to maintain both web and mobile variants of the same content.
The second half of the talk will be more technical and delve into 'silva.core.layout', content layout, and mobile templating.
The Guardian API - 1 Year On
What's changed in the year since we launched the open content beta?
Talk, 45 minutes (intermediate)
One year on from releasing the guardian API we are preparing to come out of beta.
What have we learnt, what has changed and for those who haven't seen it during it's beta, what actually is it.
The Guardian and Appengine
A story about a massively scalable app written to journalistic deadlines
Talk, 45 minutes (beginners)
"Let people viewing the page vote at anytime whether they like or dislike what the party leader is saying. Oh, and lets show it with a real time graph"
3 election debates 3 days of development How did we scale this to handle potentially millions of views
Theming websites with XDV
We write XSLT so you don't have to!
Talk, 45 minutes (intermediate)
XDV is a way to apply a style/theme contained in a static HTML web page (usually with related CSS, JavaScript and image resources) to a dynamic website created using any server-side technology. The theme is compiled down to an XSLT file which can then be deployed with Apache, Nginx, or in a WSGI pipeline.
This talk introduces the XDV rules syntax; compares XDV with Deliverance; and presents some examples of XDV in production.
What does it all mean?
Developing ontologies to expose the semantics of your data.
Talk, 45 minutes (intermediate)
With existing data storage and presentation software, you know what your data means but the computer does not. You can present the information to humans, but processing the data by applications requires direct assistance by the human programmer to provide meaning (semantics) to the data.
The semantic web is about making the meaning of your data explicit so the software itself can act differently based on the data and the relationships within your data. The 'holy grail' of the semantic web is to use explicit semantics to allow programs, i.e. ones you have never heard of and ones that have not been invented yet, to be able to automatically use your data; as well as to allow you to write programs that will work with data you have never heard of when you wrote the program.
Semantic Web technologies build on existing exchange and serialization technologies such as RDF and XML to enable you to represent the knowledge within your data; such a representation of an information domain is called an 'ontology'. The Web Ontology Language (OWL) is one way to express semantics within your applications, it is developed and endorsed by the World Wide Web Consortium.
There is another talk called 'Django and the Semantic Web' providing a more general overview of the semantic web, this talk will concentrate on how I have attempted to author an ontology in OWL using Python as well as in Django, and how you might approach this with your datasets.
While not intended to be a "What has Zeth done for us lately talk", I will explain how I am attempting to produce a single and consistent ontology and OWL interface for three types of data (XML, SQL and images) that I involved in creating and publishing. It will be more of a discussion, rather than the presentation of a finished solution. A dialogue on the best way forward toward a useful and generally applicable ontology implementation for those working within the Python community.
HTML5: the good, the bad and the quite interesting
A look at the role open standards play in making the web work across browsers, platforms, devices, in the developing world and for people with disabilities, including some demos of HTML5 and CSS 3.
Bruce Lawson (Opera)
Talk, 45 minutes (general)
A look at the role open standards play in making the web work across browsers, platforms, devices, in the developing world and for people with disabilities, including some demos of HTML5 and CSS 3.