The path to Continuous Deployment

At Paylogic we have enjoyed having our Django-based event ticket platform under continuous integration for a while. Now we would like to be able to deploy (easily!) as often as we want, so we are working on setting up everything necessary to get it under continuous deployment. I have been researching how other companies have done it (Django-based or not) and I would like to share my findings regarding:

- Do you need Continuous Deployment? (and what is it, actually?)
- What you need.
- Common ways to deploy and rollback.
- What are the most common problems in setting up Continuous Deployment for Python applications and what to do about them.
- How we do it.
- Recipes (for example, how to slowly roll out features).

The Advantages of Diversity

Geeks like to think of themselves as special. Whether they are or not, this doesn't mean that they have all the necessary skills to keep a complex project moving forward. This talk tries to explain why the open source world would be improved by a broader engagement with a wider public. This cannot happen until we accept that diversity has real advantages.

Class-Based Views: Untangling the mess

One of the big changes in Django 1.3 was the introduction of Class-Based Views. Class-Based Views represent one of the biggest stylistic changes in Django since Magic Removal, and there's been lots of confusion surrounding them.

This talk will be a brief tutorial, providing some background and dispelling some of the confusion around the use of Class-Based Views. It will also look at some interesting possibilities that are made possible by the use of the class-based view framework.

Introduce Django to your old friends

Django 1.5 introduced a configurable User model, fantastic! Now what? With the increased flexibility of user models, integrating Django into an existing infrastructure is now easier than ever.

This talk gives an introduction to the new configurable User model, and then walks through how to integrate Django applications to authenticate against already existing identity management systems like LDAP, Kerberos, etc.

Getting past the Django ORM limitations with Postgres

With most frameworks the ORM attempts to treat all databases equally, this results in developers being limited in how many advantages they can take of their database. In particular Postgres has many features which developers would love to take advantage of but are not easily accessible via the Django ORM.

Bleed for Speed: Django for Rapid Prototyping

Come one, come all to the DjangoCon sideshow to see feats of inhuman speed as we take Django for a spin with rapid prototyping. Tossing security, performance, and maintainability out the tent, Rob Spectre shows a 30 minutes of tips and tricks for building rapid prototypes on Django gained over dozens of hackathons. Find the fastest path from startproject to a publicly accessible endpoint. Discover the reusable apps that cut down your hack's implementation time in half. Marvel at the testing techniques that will minimize demo-killing broken code. Step right up ladies and gents and see the framework forged in the newsroom furnace blast your entirely temporary project across hackathon deadline.

Advanced PostgreSQL in Django

PostgreSQL is the most advanced open-source database on the planet, but (except for GeoDjango) few Django developers take advantage of its more advanced features. We want to change that!

We'll talk about custom types (including Admin integration), replication tricks, specialized indexes, unstructured types such as JSON, stored procedures, and other ways to get maximum functionality and performance out of your PostgreSQL data store.

The Web of Stuff

As software developers, the world of hardware can seem confusing but alluring. Small computers are now cheap enough that useful products can be built for less than $100. But the real value from the Internet of Things comes from networking. In this talk, I'll introduce you to basic hardware hacking, and show you how Web, mobile and microcontroller technologies can be brought together using Django—with surprising and playful results.

Migrating The Future

It's been almost five years since South was first released, and in that time many things have changed - now it's time for a new migration system, built into Django itself and with new features and a solid foundation based on those five years of learning. Hear the problems in both running this kind of open source project as well as those of dealing with five different database backends, and how both you and South can learn from them.

Enterprise Django: transactions for web developers

Django has since long outgrown its roots in publishing; it's increasingly used in enterprise systems, under write-heavy workloads and strong data integrity requirements. Enter transactions — and, soon thereafter, DatabaseErrors!

This talk will start from the transactional features of databases and work its way through the Python database API, up to Django's transaction management. It'll describe what's under the hood, explain the options offered by Django, and propose practical answers to common problems.

Advanced Python through Django: Metaclasses

"The Django source code contains many advanced features of the Python language that are rarely encountered in day-to-day development work. This can make the Django source seem daunting to the uninitiated.

In this talk I will take one particular advanced feature -- metaclasses -- and explain what they are and how they work, taking my examples from the Django codebase. We'll also cover, in passing, some techniques I've found useful for understanding a complex codebase. The talk will be suitable for anybody who has both a good grounding in the Python language, and a sense of curiosity."

The Imaginative Programmer

In the world of programming nothing is more irritating than the "artist". Programmers who are all "front-end", business guys who are all "ideas", and designers who can't draw. I say real programmers don't need to be artists. Rather, a programmer needs to have the skills necessary to take their imagination (or other people's) and translate it into working software.

This talk will contain many of my secrets for turning ideas I have in my mind into real things. I will lean heavily on the arts, music, and writing, but ultimately this talk will be about implementing software. There will be no fluffy spirituality or hand waving in this talk, just real tricks to help you make stuff.

Getting recommendations out of nothing

When it comes to dealing with a lot of products and almost no information about user preferences, recommendation system needs to squeeze out all the data that is available and needs to do it fast to produce valuable information.
The talk will cover a case study of building a recommendation system for an e-commerce website that has no rating system with Django, Solr and Redis onboard.

Prehistorical Python: Patterns past their prime

There are many idioms and patterns that used to be a best practice but isn't anymore, thanks to changes in Python. Despite that they often show up even in new code, and some of these patterns are even explained to be Good Ideas at stackoverflow and similar.

This talk will bring out the most common of these patterns so you know what they are, and why you should avoid them.

Having Your Pony and Committing It Too

For many years before 2012, the topic at the tip of every argument-seeking tongue at Django Conferences was ""when is Django going to get on Github?"" Getting the core framework on the social coding site was the first stride in breaking down the barriers to having anyone and everyone not only having a pony, but getting it into core too. Now that this important step is almost a year in, just how easy is it to take the step from end-user to core-contributor? Delightfully Easy.

So easy, that I'll be breaking every rule I know in giving a talk and actually attempting to get a feature from idea, to code, to request, to a live haggle-and-debate session with core contributors in-audience, to pull request to (hopefully!) merge all within 30 minutes. Advice from a variety previous contributors on will be provided throughout the demonstration, including tips for getting very small bugs fixed quickly to strategies for getting necessary groundswell for larger full-feature ideas.

Taming multiple databases with Django

Support for multiple databases has been introduced in Django 1.2 in 2010, and, while amazing, it's still a minefield filled with programming gotchas. I've stumbled upon many of them while developing a highly distributed system at SetJam and then Motorola Mobility and want to share my experiences with you. Knowing how to properly route queries, migrate schemas (using lovely South library) and then test the whole thing, while dodging chainsaws of Multi-DB API, will probably save you a few days of cursing.

Just to ignite your curiosity: Did you remember to set `_for_write`correctly in all methods of your custom `QuerySet`?

How to combine JavaScript & Django in a smart way

Have you been using JavaScript more and more when building your web applications? Are you implementing REST API frequently? If so, you have probably realised that server-side generated content is no longer enough to provide cutting edge user experience.

I would like to show you how to avoid jQuery callback hell and how to gain more flexibility using MVC on the client side. I will introduce tools for managing modules in JavaScript and will teach you how to become more productive with CoffeeScript. I will share my experience of integrating Django and sophisticated JavaScript stack from two points of view: RESTful API and static files management. Let the trip begin!

Mock your database

Databases are slow. Well, if the goal is 1 millisecond per test they are anyway. We want to avoid interacting with the database as much as possible when testing, especially if the tests aren't anything to do with the queries.

This talk will look at various ways of avoiding those pesky database queries and making tests faster!

Does your stuff scale?

In just over 2 years, Potato has grown from a single developer to a team of seasoned software engineers across 4 continents, building complex web apps for large tech companies and creative agencies. At the heart of that growth are two very important ingredients: Django + Google App Engine.

The first part of this talk is about accelerating the growth of your business with Django + App Engine by taking away sysadmin and the headache of provisioning physical servers, and letting Django developers get on with writing good, scalable code. The second part will cover different options for running Django on App Engine, rapid prototyping with the (NoSQL) datastore, performance tuning (task queues, caching) and how to handle thousands of concurrent requests without breaking a sweat.

Apps for advanced plans, pricings, billings and payments

Every e-business website needs account management which involves defining plans, pricings, limiting resources, invoicing and accepting payments. These are complicated tasks that can be made easy to implement using django-plans and django-getpaid. The talk will cover usage and integration of above mentioned django apps in example case study.

Planting Open Source Seeds

This talk will be an in-depth review of the stages that most open source projects go though, and the decisions their maintainers face. Requests will be used as an example — lessons learned and best practices will be covered.

Circus: process & socket manager

Circus is a process manager we developped at Mozilla while working on high scalability, we wanted to have a way to deal with our processes directly from python, and in a better way that's what possible with the standard library.

Circus uses zeromq in its internals, and thus is easily extensible. We'll present you how you why we built circus, how to use it and some core concepts that were useful in the conception of the tool. Also, we'll demonstrate how easy it is to plug circus with a Django stack.

Taming Ajax and Django

After several years in the web business, trying to find the right way doing ajax with django, we came across varying techniques of integrating ajax into django apps. Always keeping asking ourselves ""is this the right way?"", we finally found a solution which works best for us.
We will take you on a journey from ""hashbangs"" to ""push state"", from ""prerendered html snippets"" to ""client side rendered templates"", and let you know what did and didn't work for us.

Dynamic Models in Django

Django has been built on the assumption to have upfront static data models; i.e. the developer implements them completely before deployment. However, there are numerous real-world uses cases that require to have dynamic models that can be created and amended by users or some kind of user actions. Examples could be: customizable products for a shop, unique content types to represent web site content in a CMS or online surveys that are created on the fly.

There are various conceptual options to solve this problem. The most prominent ones are: a) Entity Attribute Value Models, b) Pickeld Fields and Pickeld Models, c) Database DDL operations at run-time Most of which have been discussed intensively and the Django community has developed numerous apps. I will compare the various approaches and apps in terms of usability, speed, features, sweet spots and preferred use cases. This will support any future evaluation for a specific project. But it will hopefully also trigger a fruitful community discussion on the importance of this feature for Django in comparison with other applications and frameworks like Zope/Plone, Magento etc.

Processing payments for the paranoid

The Mozilla Marketplace is the app store for Firefox OS and this Django powered site takes payments from users.

Combined with issues like localisation, identity and scale - we are processing payments through Django. This talk will cover the marketplace, the architecture of the system and how we cope with all the paranoia.

Fractal Architectures

An alternative take on Django's traditional layered web service architecture.

Building tools that developers will want to use

Having a strong community that contributes a variety of packages and frameworks is an essential component to the success of any language. Python boasts nearly 30,000 contributed packages listed on PyPI and that number is growing every day. Within those packages, there are inevitably a bunch of duplicates (packages that solve the same problem). What makes developers choose one over another? Why do some packages go nearly unused and some have cult-like followings? During this session, we'll talk about how to design tools that developers actually want to use and how to optimize them for developer happiness.

Thread Profiling in Python

This talk will give a tour of different profiling techniques available for Python applications. We'll cover specific modules in Python for doing function profiling and line level profiling. We'll show the short comings of such mechanisms in production and discuss how to do sampled profiling of specific functions. We'll finish with statistical profilers that use thread stack interrogation.

Keynote

 

Keynote

 

Play nice with others

I go through the various tools and techniques that we use to make our Django apps easily reusable across sites and environments with different requirements on data being stored, business logic and backends that enable us to have one set of apps that we deploy over and over and just easily plug in the part that is different in each case without sacrificing clarity or ease of development.

All tools and approaches are used in production and are open source.