Add an eventSessions at EuroPython 2012 about Django in Grand Hotel Mediterraneo
Tuesday 3rd July 2012
-
Django Under Massive Loads
The Python web framework Django can handle extremely high levels of traffic… with appropriate design and support. We’ll go over techniques to keep your Django site from being crushed under high load.
Topics include:
- Schema/model design
- Caching
- Efficient view function design
- Caching
- Template design for high performance
- Caching
- Database tuning and sharding
- Caching
We’ll also discuss caching.
-
How to bootstrap a startup using Django
by Jannis Leidel and Philipp Wassibauer
Based on our (Philipp Wassibauer and Jannis Leidel) experiences building Gidsy.com this talk will give you valuable insight as to how your infrastructure will evolve and how to set up the basic components (Loadbalancer, Webservers, DB, Caching, Celery, CDN, …) of your site.
Outline:
- Basic project layout - How to handle different configurations and package your project to make it easy to deploy and install.
- A basic timeline of how your infrastructure needs will evolve - Starting from the initial 1 server setup we will talk about how and when to scale out your servers.
- Replicate production environments in development - We developed a way to have all your services (Webserver, Celeryd, Solr, Cache, Compass compiler, …) running using one management command.
- Setting up Chef recipes to provision your servers.
- Dealing with cloud based servers - Tips and tricks on how to manage your cloud based server using tools like Instagrams ec2-ssh.
- Automating deploying to a bigger infrastructure (5+ servers) - Once the infrastructure becomes larger the deployments become more tedious. There are a few automation tools for these scenarios like the Etsy Deployinator.
- Tips on performance - How to find and remove performance bottlenecks.
Wednesday 4th July 2012
-
Healthy Webapps Through Continuous Introspection
Every application has its hotspots – small portions of code that consume considerably more resources than all of the other code combined.
Django apps are no different. Some pages, invoked with the just the right, or wrong input, can bring a server to its knees, hogging the CPU and taking many seconds, or in extreme cases even minutes to render. By keeping workers tied up, the whole system can then become slow to respond, or collapse altogether.
Many webservers have a crude built-in failsafe to prevent this. They automatically kill workers that fail to complete their requests in time. As a result, you may not fully appreciate, or indeed realize at all that you are routinely serving 500 pages, denying users access to your service, or leaving uncommitted database transactions – possibly even slowly corrupting data. Workers killed by force leave virtually no forensic traces and so even when issues are suspected, it’s hard to pin them down.
The cause behind these hotspots can be poorly generated SQL queries from the ORM, an algorithm with non-linear complexity, excessive disk or network IO, or lock contention in the database – to name just a few.
Oftentimes these problems escape a developer’s attention, as dev and test environments simply don’t have the dataset, level of concurrency or sheer size of the real thing.
In this talk we’ll address the challenges of tuning your Django app with continuous automatic runtime inspection tools, including homegrown Dogslow. We’ll uncover the pages that consume disproportionate amounts of time and cycles to complete and the pages that get killed altogether.
We’ll discuss several ways to help you identify and eliminate the hotspots, both passively through monitoring exclusively, as well as actively by selectively interrupting workers before they get killed and examine how to effectively interpret the automatically collected forensic evidence.
Thursday 5th July 2012
-
Fully Test-Driven Django With Selenium
The concept: run through the official Django tutorial, but with full TDD
Includes browser-based testing with Selenium, using the new WebDriver API
In-depth unit-testing, including the Django Test Client and tools like Mock
Discussions of TDD philosophy: what to test, what not to test, how to testhttp://www.tdd-django-tutorial.com/
https://github.com/hjwp/Test-Dri...come prepared! you’ll need git, firefox, python2.7, django1.4 and selenium installed.
This tutorial is aimed primarily at people who want to learn about one or many of:
- Django
- Selenium
- Test-Driven-Development
So it’s aimed at beginners of one kind or another – if you are already well versed in all three, then you may not get much out of it.
The idea is to run through the steps covered by the official Django tutorial, covering the essentials of Django from a beginner’s point of view. However, at each stage, instead of “just” writing the Django code required to build our site, we first write tests.
And we don’t just write unit tests! We start by writing “functional” or “acceptance” tests, using Selenium - which means driving a real browser, and checking the actual behaviour of the site as it is rendered, from the user’s point of view.
Why should you listen to me, I hear you ask?
Well, I was lucky enough to get my first “proper” software development job about two years ago with a bunch of Extreme Programming fanatics, who’ve thoroughly inculcated me into their cult of Test-Driven development. Believe me when I say I’m contrary enough to have questioned every single practice, challenged every single decision, moaned about every extra minute spent doing “pointless” tests instead of writing “proper” code. But I’ve come round to the idea now, and whenever I’ve had to go back to some of my old projects which don’t have tests, boy have I ever realised the wisdom of the approach. So, I’ve learnt from some really good people, and the learning process is still fresh in my mind, and most importantly, I still have the passion of a recent convert!
-
Content Management professionale con Python nel 2012
Django o Pyramid, rapidi da apprendere e mettere a frutto, sono potenti strumenti di lavoro, utili a costruire siti gestiti da un solo autore o applicazioni web di servizio. Ma se avete bisogno di far collaborare un vera redazione alla pubblicazione di un portale ricco di contenuti, non troverete stoffa pythonica migliore di Plone!
Come costruire un servizio di Content e Document Management potente e professionale nel 2012?
Facciamo il punto su cosa offre il mondo Python di oggi.
-
Making DISQUS realtime
Currently in development is the DISQUS realtime service. This talk will detail what it took to add real time to a truly “web scale” django app.
This will include:
- Numbers! how much concurrency and msg/s we are supporting with realtime
- Overview of the architecture (redis + gevent + flask) and why those choices were made
- How we baked high availability into the application, not just the infrastructure
- Overview of the hardware involved
- Lessons learned (what broke hard, what worked awesome)
I hate long talks and love open spaces. Also, I’m not the world’s leading expert in real time anything. So I’m planning on making this a 20-30 minute talk, and then converting it to an open space for 20-30 minutes which I will lead. The goal is to get a good conversation going around the topics I will have presented. So I’d prefer a 45-60 minute slot.
Suggested audience experience:
- Medium/Advanced level experience
- Familiarity with Flask, Gevent/Eventlet would be really good.
Friday 6th July 2012
-
Composite Key Is Ready For Django 1.4
by Simone Federici and Michal Petrucha
Currently Django models only support single column primary keys.
Multi-column primary keys support would improve Django integration with legacy databases (whose schema cannot be changed and usualy have multi-column primary keys).
This project allows the usage of django ORM with Multi-Column Primary Key and includes Foreign Key support.
In this talk we will explain the problem, propose a solution and present two projects aiming to solve it.
One of them is a pluggable app which monkey-patches Django’s ORM. Its obvious benefit is you can introduce it in a project without maintaining an unofficial Django fork.
The other one is the long-term solution approved of by the Django core team. It was part of last year’s Google Summer of Code and we will talk about what is ready and what is yet to be done before it is included into mainline Django.
-
In search of reduced loading times
The talk will discuss ways to achieve reduced loading times of django web applications. The focus will be on optimizing and re-architecting the web application itself, instead of throwing more hardware at it.
Some of the topics (in a high level) of the talk will be optimizing SQL queries, caching and executing operations in the background as well as taking advantage of features that the stack provides you.
Basic knowledge of django is needed.
-
Creating federated authorisation for a Django survey system
by Ed Crewe
This talk is about the development of the user system for a online survey application.
The goal of the talk would be to impart some knowledge of the current state of open authorisation standards and how the python web application tools that are available for them may be applied in practise. The prerequisites are some background in web development and perhaps authorisation systems - experience of Django is not necessary but may be useful.
The introduction will give background regarding the application, for context, e.g. 3 million survey responses in a Perl web application being rewritten in Django with Cassandra and PostgreSQL data storage. The need to add external access control via Shibboleth (SAML2) and OpenID.
This will be followed by a summary of the features and differences between the three main open standards for third party access control, SAML2, OAuth and OpenId.
Then I will move on to the issues involved:
- mapping one or more authentication identities to a single user
- how authorisation can be derived via attributes, to automate group membership
- the use of role based access control for allocating object permissions to groups
- identity lifespan management
- mixing local and remote authorisation allocation, etc.
Next will be an explanation of what django.contrib.auth has and its likely future (a rewrite is currently under discussion). Then a review of the various authentication and authorisation add on eggs available for Django that could help deliver elements of these requirements.
This section will end with what we chose to use and the issues that this involved.
Finally, some Python code! So a look at some of the more generically useful implementation code, e.g. development of standard object permission decorators for Django class views.
Concluding with where we are now and lessons learned.
Schedule incomplete?
Filter by Day
- Monday 2nd 0
- Tuesday 3rd 2
- Wednesday 4th 1
- Thursday 5th 3
- Friday 6th 3
- Saturday 7th 0 [Sprints]
- Sunday 8th 0 [Sprints]
Filter by coverage
- Video 7
Filter by Topic
Filter by Venue
Filter by Space
- Big Mac 1
- Lasagne 2
- Pizza Margherita 1
- Ravioli 2
- Spaghetti 3