DjangoCon Europe 2013 - best Django community event.

???

Single table inheritance

Django already implements three types of model inheritance, but why shouldn’t we add to them single table inheritance, one which works just like in Ruby on Rails?

I’m going to discuss some pros of this type of inheritance, give a short sketch of already working implementation and ask whether it has to use such huge amount of metaclassing and monkey patching to cooperate with Django ORM. I will also present some benchmarks to show whether it is already competitive.

???

Cold Turkey Django

My first serious Django project was http://datoz.com, a real estate information service that got very complicated very quickly. I had to learn, at the same time I was learning Django, about GeoDjango and Internationalization. Many things were learned, but also many mistakes were made.

The talk would focus on what I did wrong, what I did right, and what I would do differently now that I know the framework much better.

???

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.

???

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!

???

Django and MongoEngine a match made in heaven?

Mongoengine was born from a love of Django's own ORM allowing easy access to MongoDB, whilst providing simple query semantics and data validation.

The downside has been integration with Django was always left the user. This has all changed! The new django-mongoengine library provides deep integration will Django - providing all the Django goodness you've come to know and love.

???

Next building block: web applications

Reusable Django apps are great, but wouldn't it be even better if you could assemble whole web applications? If installing photo sharing app next to your blogging one would immediately enable you to add photo slideshows to your posts?

In this talk we will take a look at few less known pieces and techniques from Django universe which we can use to build stand-alone web applications that can automatically augment functionality and user interfaces of other applications installed in the same environment.

???

Asynchronous code in Django.

There are situations when you need to perform a few calls to remote services to render a view. Its annoying you have to perform then one by one and each of them blocks the code execution for precious (mili)seconds. If only there were a way to make them simultaneous... Now there is!

In this talk, I will present a result of my research about combining Django with Twisted. I will show how asynchronous components can share a process with a Django application and how synchronous code can wait for the result of the asynchronous call.

???

Do you feel the chemistry? Developing scientific applications with Django.

Django was created as a framework for news-oriented websites and was quickly adopted by online startups as it supports agile development without design compromises. Great success of Django in many new web projects, raises a new question, how well will it perform when applied to existing computing environments? The ChEMBL database (https://www.ebi.ac.uk/chembl), is the leading open resource focused on storing data related to bioactivity of small molecules and is used in the field of drug research. With the goal of improved data curation in mind, the ChEMBL data model has been introduced to the Django framework and related components (Celery, TastyPie, Solr, Bsckbone.js)

Is Django capable of operating on the chemically-aware ChEMBL database, with a non-trivial structure, already existing triggers and constrains, while keeping its own tables in separate schema? What if the database engine is Oracle, not very common in the world of open-source agile startups? What if it has to handle binary data kept inside the database, a feature not officially supported by Django core software? Is all that possible without alteration of Django code? And what about advanced searching and data mining capabilities, the Semantic Web and other aspects that are important for every research project? This is just the tip of the iceberg…
The presentation will try to address all those questions, identify some common drawbacks in the Django architecture and what can be done to fix them. More importantly, the talk will define a fully featured Django-based application stack, capable of supporting existing relational database driven projects. It will cover creating a model from an existing schema, automatically exposing a RESTful API and automatically generating API documentation. Details on how to implement advanced search options utilizing either Solr or bespoke in-house search indexes, will also be provided. Finally, a client-side templating approach will also be presented, providing an alternative to the default Django templating system. The result of bringing together all of these components will not only be a demonstrable web application, but also a recommended approach for interacting with complicated and mature database systems.

???

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!

???

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).

???

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.

???

Website security in Django

Every three years or so, the Open Web Application Security Project (OWASP) publishes a nicely reviewed list of the top 10 vulnerabilities and risks in web applications. The OWASP top 10 list doesn't cover every single risk to your website, but it's a very good starting point.

In this talk, I will go over how Django helps you avoid falling into the problems on the current list. Some of the items have built in protection in Django: you get the fix for free. Others require you to do all the work yourself because Django cannot read your mind (yet!). Some are a mix of both. Don't be a victim of the most well-known problems in the security space. Learn how your framework helps you.

???

Django and Healthcare

In the past 3 years, I learned - the hard way - that building a product for the health care world is quite difficult. There are lots of rules and regulations in place in order to protect the safety of everybody involved : patients, doctors, nurses and, of course, insurance companies.

Hopefully, I used Django. In this talk, I will explain what really matters in terms of security when you really care about the data uploaded by your users. In fact, lots of small tricks can be used for every product out there! Let's see how we will enhance the security of your future Django projects.

???

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.

???

Forms for the Fearless

Django has an extremely rich set of built-in features for forms, and forms are used in countless ways in Django projects. Given how much functionality there is, it's no surprise that some of these features are little known or poorly documented. However, thanks to the excellent open source community around Django and its well-written source code, we can accomplish many things with Django forms that don't appear in the manual.

This talk will explore the inner structure of django forms, including a walkthrough of some of the key code sections, and discuss some of these lesser-known features.

???

Django and Money

It is easy to make money with Django. Just get hired as a contractor. However, actually storing and using Money as distinct type requires some forethought.

This talk will cover why you might want to do this, an implementation and some common pitfalls (I found whilst doing this work, and that you might encounter)

???

Surfing fast on slow connections

We all (probably) enjoy fast internet connection. That is until we travel and become dependent on expensive and slow mobile link. Or desperately try to squeeze our bytes through over-burdened conference wi-fi. Let's not even mention hotels.

In this talk we'll take a look at some of the low-bandwidth friendly guidelines, tools available to Django developers and how to use them effectively to make fast websites quickly. It's a win for all users, even those on fast connections.

???

From data set to useful website

Imagine you are working in a laboratory, or perhaps an office environment, and you have a bunch of data you would like to make available online. Perhaps not for broad public viewing; maybe just internally so your research group or department can see the data. You possibly aren't a full-time web developer, but you can code and use a framework to help you achieve your goal. So using Django is not your primary mission, it's a tool you want to use to get your real job done.

This talk will walk through a situation like this, showing some low-impact ways to get from raw dataset to something you can view in a web browser. I'll take a real dataset from somewhere and turn it into set of web pages. The goal is to show one path to learning the minimum necessary to create from scratch with Django in a short amount of time so you can then get back to breeding flying mice or writing more documents.

???

Administrative Interfaces

Contrib.admin has been one of Django’s marquee features since its inception, and it remains strong despite getting long in the tooth. The admin’s longevity is a testament to its forward-thinking design.

Calls to “refresh” the admin are often limited to cosmetic improvements, but we should be thinking about more than a fresh coat of paint. We’re still using the current admin today, years after it was created; we need to build with the assumption that users will be seeing our work years from now. How do we design and build something that can remain relevant and useful?

This talk will cover:
A tour of the existing admin’s architecture and pain points, as well as existing efforts to improve (or kludge) the admin.
Analysis of administrative interfaces on the web: what good ideas can we appropriate?
Backend considerations: the admin rests on top of several Django components, some of which could bear improvement (notably forms).
“You mustn’t be afraid to dream a little bigger, darling.” Explore wild ideas that might have merit, and might not.
* The path forward: replacing the current admin is not a backwards-compatible operation. An exploration of how updating the admin might work.

???

Don't be afraid to commit (or participate in other valuable ways)

Many members of the Django community would like to participate and contribute more, but are not sure how to, or even whether they can. I will show, with concrete examples of both coding and other kinds of contribution, some of the easy routes in to participating for newcomers - particularly ones that might be less obvious.

It's not enough to just to talk: I will also hold a how-to-commit workshop, aimed at getting new contributors over the first step to making a mergeable commit to a Django project. The workshop will particularly address the single most common comment on a newcomer's commits - "needs docs and tests" - by incorporating a tutorial on writing and running tests, and the basics of contributing to documentation.

???

Caching Django

This talk aims to give an overview of caching in Django to the uninitiated. The talk will cover the basics of caching, why you should cache your data, what data you should cache and more best practices of caching. We'll also look at some caching "gotchas" and cache invalidation.

We'll look at the caching library included in Django as well as a few popular third-party caching libraries.

???

Coding for the Modern Warzone

When you deploy web applications, you do so onto air-conditioned servers on UPS powered racks with reliable, redundant fat pipes connected to a world of web services and data. Infrastructure is for the most part thought of as reliable, its one of those things you usually get to assume. But, what happens when you deploy in a very different environment, one in which the connection to the outside world would make a 3g connection look fast and reliable, where your any of your servers might overheat, and where that already clogged internal network cable has a spade go through it mid message?

Its not actually impossible, and you can do it all with python, and I hope to explain how, why and what else you might think of. The talk is going to be split down the middle, one half focusing on low level python networking, and the other about building your apps and daemons with fragility in mind. Most situations are not going to be as extreme as a construction site/event space in Beijing, but it doesn't hurt to build leaner and more rugged applications even when they are running in the cloud, because lightning can strike the same data centre twice.

???

Using django.test.Client beyond tests - it can also migrate data from legacy systems!

On a recent project, we ported a complex application from PHP to Django, which included the migration of the old data to the new system. This meant duplicate (triplicate) code for the business rules - in the new application, in the data migration scripts; and in the reports about old data violating the new business rules. We had to find a better way.

This talk will describe the approach that worked out for us (with code examples), confining the business logic to a single place: the new application. The former data pump scripts would extract the data from the old system, and enter them into the new application just like an actual end user would, by filling out and submitting forms. Thanks to django.test.Client, we could do this all in memory and rely on ValidationErrors to find bad data. In addition to getting rid of the code duplication, this also provided us with additional benefits, such as a superb end-to-end integrated acceptance test suite that exposed unspecified corner cases (even unknown business processes!) and many more.

???

Linux process management -- you're doing it wrong

Process management lies at the core of Un*x servers. And yet, for the last few decades, we seemingly haven't been bothered to do it right. Getting a daemon to run and stay up requires crossing a maze of twisted initscripts, all alike, playing hide-and-seek with pidfiles or (ab)using cron in a variety of ways.

The talk will outline many of the popular (and wrong) ways to manage processes comprising your application and a few of the less wrong ones. It will also introduce a new process manager we have written, which strives to get things right and gets pretty close at the cost of being mostly Linux-specific.

???

Django for Designers

Django is one of the most accessible programming languages for web folk skilled in design and front-end development, but our current tutorials and resources are very engineer-focused.

This talk covers why Django is perfect for web designers and how to get more web designers interested in back-end programming, by covering a mini Django tutorial tailored to web designers, recommending resources that are designer-friendly, and offering strategies for web designers to continue pushing forward and not get frustrated.

???

Deploy your Django app on Linode with git push

One click to launch a preconfigured Linode ready to deploy your Django app with a simple git push command, using a StackScript. Changes are live in under a second, with no downtime.

The talk will include a quick walkthrough of the process, an explanation of Linode's StackScript and the mechanics of this specific script, the final setup that your project will be living under (nginx+uwsgi+supervisord), and the simple git hooks used to make this work.

???

Django on Amazon Web Services

Amazon Web Services (AWS) is the magic behind Heroku, Netflix, and many of the top sites in the world. Learn how to you deploy to the cloud and understand/mitigate your platform lock-in.

The talk will cover the many deployment options available from AWS and explain to the uninitiated what it means to deploy with R53+S3+EC2+RDS. We will be covering the service options from the easiest turn-key Elastic Beanstalk service down to a custom AMI which can be refreshed from your CI server. We will also cover how how you use S3, cloudfront, and other tools to make your deployed Django app both fast and less expensive at the same time.

???

Model-Mommy: Smart fixtures for better tests

Preparing the database for tests is no fun. And hacking factories to create complex scenarios can be extremely tedious.

Model-mommy offers you a smart way to create fixtures for testing in Django. With a simple and declarative API you can create many objects and a whole object graph with a single line of code.

???

Real-time Web Applications with Mushroom

This talk provides a brief introduction into real-time messaging and gives concrete code examples with live demonstrations involving the audience using a framework called Mushroom.

Mushroom is a real-time web messaging framework which is based on gevent and supports WebSockets and long polling transports. It also contains code for inter-process communication via message queues.

???

Views can be Classy!

A mid-level intro into how to use Django's generic CBVs, including:

• avoid defining view characteristics in urls.py


• how to write your own mixins to save time & trouble


• useful mixins from the django-braces package

Full disclosure: I'm one of the two main contributors to the django-braces project.

???

Another take on Dynamic Django models

Topic of creating or modifying dynamic models in Django at runtime crops up every now and then, but there isn't a single standard "best practice" solution - probably because each use case is slightly different.

The talk will present various ways to do dynamic models in Django and focus on the pattern we ended up using on our projects: stuffing the extra model fields in a serialized dictionary.

???

Effective tests run fast as a leopard.

An effective test suite is one that runs quickly and testsyour code precisely and thoroughly. It also gives meaningful feedback, and is well-understood by its users, the developers.

There are a number of anti-patterns that Django implicitly encourages, including testing external code and relying heavily on persistent storage, but with the right tools and the right techniques, these problems can be avoided. This talk will focus heavily on real-world techniques you can use to refactor your code and your tests to radically improve the speed and precision of your tests, and in the process, your web applications.

???

Hidden gems of the Django testing world

Testing has always been an important part of building a Django application. However, two very useful testing tools -- mocks and factories -- aren't mentioned by Django's testing documentation.

This talk will provide a brief introduction to these two tools, showing how they can make it easier to test your Django applications, and easier to maintain your tests over time.

???

A Frontend Framework for the Django Admin Interface

This talk is about Djangos admin interface, it's shortcomings and how we might be able to improve and modernize the interface by fixing the foundation and adding a frontend framework.

I'm going to show how the backend (Python) needs to be updated, then I'll outline the different elements of the frontend framework (HTML/CSS/JS) and briefly explain how the documentation could be improved. In the second part, I'm addressing the topics of design and audience as well as sketching a possible roadmap. Finally, I'll show an alternative approach based on splitting the admin interface into an API (via Backbone.js, Spine, AngularJS, Ember.js) and a frontend.

???

DaNKinDaB: a Django based webserver

DaNKinDaB (Da New Kid in Da Block) is a new wsgi/http server based on django and gevent and aiming to be an easily deployable infrastructure with an easy (and web based) configuration, so that the developer can be happy, and the ops guy can have his fun. Based on the idea behind mongrel (zeromq+dispatcher) DaNKinDaB brings some interesting twists, offering webbased (grappelli anyone?) configuration, load balancing, github integration (code pull on webhooks call) and more in a completely python-based implementation and a django based infrastructure giving the users the ability to decide whether to put every configuration in a local sqlite or in a more performing postgres database for integration with other tools.
The talk targets the presentation of the tool per se, then the discussion of the reasons bringing to this kind of implementation compared to other well established servers (i.e. why a developer would like this), and why the ops and the datacrunchers might like such a tool, and what the future can bring to both the developer and the operations guy (jenkins, RESTful API for third party integration with chef or puppet, local persistence of shared configuration)

???

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?

???

`get_or_create` considered harmful

Most Django applications reach a point when a following pattern appears: get an object from the database and update it, creating it first if necessary. The framework provides a seemingly trivial way to do it: get_or_create. In fact, using it right is trickier than you might think.

In this talk I will discuss real world problems with the get-or-create pattern and the get_or_create implementation. In particular, I will focus on concurrency issues, cross-database compatibility, unique constraints (especially unique_together) and surprising behaviour. The talk includes solutions that I've grown for these problems.

???

Designing a good API: Lessons Learned

At Paylogic we are opening our Django-based event ticket platform to the world by offering a REST API that merchants can use to create and manage their events, and that third parties can use to sell these events.

Designing a good REST API is difficult. We have been researching what approaches other companies have taken and we have made our decisions. We have taken a strict, simple and highly opinionated approach, and I'd like to share it with the community.

???

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.

???

Everything looks like a nail

While the open source community excels at building backend and server-side tools, it has generally failed at producing polished user-facing tools -- especially when it comes to to tools that support the development of software itself. Nowhere is this more apparent than in the Python and Django communities, where "import pdb; pdb.set_trace()" is considered the height of debugging.

In this talk, I'll look at the areas where our software development tool chain is failing us -- and look at what hope we have for fixing these problems.

???

Single page web applications with Django

Rich applications with complex UIs written in JavaScript are becoming a staple of the modern web. So how do we get there using Django? As it turns out, modern tools make it quite simple.

The talk will focus on the process of creating single page web applications using Django combined with a JavaScript framework (using Sencha's ExtJS as example). I will outline steps needed to get started building these apps, describe how to structure your client-side code using MVC, how to bind your Django models to interactive UI widgets using JSON over AJAX, and how REST can help you organize your API. I will conclude my talk by announcing and briefly demonstrating django-xmin an open-source JavaScript admin interface which serves the same functions and may be used as a replacement for Django's contrib.admin application.

???

Oh, the usability! Making usable web apps as a Django developer.

Technology was supposed to make everybody's lives easier, but the usability of most web apps today is still moderate at best, disastrous at worst. Although we've learned by now not to use white text on yellow backgrounds, there are many more subtle but unnecessary usability problems, which are still common today.

Usability is everybody's responsibility. As Django developers we make decisions about usability all the time, from processing forms to producing error messages. This talk will cover a range of usability problems that are common today, and how to prevent them. We'll look at practical examples of both great and disastrous usability, and discover what we can learn from those.

???

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.

???

Working smart with Django (so you don't have to work hard)

Django is a very powerful and flexible framework with a great mascot. But sometimes, as your project evolve, that poney can behave like a wild stallion.

This talk presents a collection of practical strategies I've learned over 4 years working with "rescue missions", helping companies recover projects, helping teams to reduce the development lead time and maintenance cost.

???

How my sideproject turned distributed, complicated and profitable

In 2008, I bought an ebook reader. Then I hit the first problem - how to find the ebooks I wanted to buy? So I wrote some code; and the code turned into a website. And now 4 years later, Luzme finds ebooks at a good price for readers on 6 continents.

What started as my Django side-project on one machine now uses 22 VMs on 3 continents, including 3 types of datastore (MySQL, MongoDB, Redis) and a capability-based task queueing system based on Celery & RabbitMQ. The talk will cover why and how and what's next.

???

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.

???

Does your shit 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.

???

What about Diazo?

Diazo is a modern technique to perform XSL transformations. With Diazo you theme your (or any) website without even touching the code. This gives a whole new perspective to templating since the content and the theme can be developed independently. In the end Diazo merges the two to deliver themed content.

Diazo is yet another level of abstraction and therefore criticized by a lot of people (developers). The Plone community completely adopted the new technique and cannot live without it anymore. With my talk I want to show people the possibilities and capabilities of Diazo and also what we can learn from the Plone community.

???

Let’s bankrupt Heroku: make your Django run fast

Django can support apps serving thousands of requests, they say – so why is my app so slow?

This talk will be about a few simple rules that can keep your site from getting overwhelmed by even moderate traffic burst. Some of them require little to no code alteration or just being cautious about libraries you use. The talk will be based on real cases from our previous work, from simple mobile backends to big MMO games.

???

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.

???

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.

???

Developing Django apps: from python noob to django developer in 6 months

Between the vision for a web application and the deployment, a noob has to learn many details about Django and the ecosystem of tools that support it. A year ago I thought python was a snake, Django a gypsy musician and Celery was to be eaten with tzatziki. Today I have a geographically-enabled Django webapp in production.

I won’t introduce the various Django tools like South, Celery or GeoDjango, but will speak of the ways a noob can learn Django, interact with the community and quickly turn their ideas into real web apps. Python/Django is one of the best documented programming languages; but it takes some time to learn how to navigate docs, blogs, apps, snippets and user groups. I’ll show newbies how to quickly accelerate in Django.

???

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.

???

Why Django sucks

Writing code on a day-to-day basis is one thing, but it's healthy to take a step back and look at the big picture from time to time. When I do, and see some patterns emerging, and not all of them are pretty. This talk will be about those patterns, and how they should be fixed.

My perspective is from a Django-getting-things-done-perspective (have built 10+ sites), not a core developer one. Bring stuff to throw at me :)

???

Code for Culture

We all know that code and culture have a close relationship. Culture affects how and what code gets written. Different values and priorities lead to different features, different architectures, even different languages. But what about the other direction - how does the code you write affect the culture around you? And more importantly, how could it?

This talk will explore the potential for code to go beyond making a product or even making a company, and argue that software developers can, and should, think about software as societal fabric. Programming, like architecture, sets the boundary conditions for human behaviours and interactions. As software engineers, we should consider ourselves social architects, and our potential to be much greater than simply product developers.

???

Building the programmable Web.

As Web developers we share a common language and set of design principles around how to build sites and apps, but when it comes to Web APIs the landscape is less mature. This talk will take a lightning tour around how to talk about, think about, and design Web APIs.

We'll be covering: Why Web API tooling needs to grow up. REST & Hypermedia - when does it matter? Designing relationships, URIs and media types. How we can make our APIs web browse-able and why it matters. Building Web APIs with Django - what could we improve? Where do we go from here?

???

A pragmatist's guide to Hypermedia APIs.

What are Hypermedia APIs, and why should you care? This talk will dive into what the REST community means when they talk about the "Hypermedia Constraint", and show why Hypermedia APIs really do have the potential to radically alter how we program the Web.

It will demonstrate concrete examples of how Hypermedia APIs can benefit end-users, explain why hyperlinking does not equal hypermedia, discuss how to design and build your media types, and take a peek at how the future of Web APIs might look.

???

Deploy your Django app in 5 min with a PaaS

How can you avoid servers and get back to coding? Platform-as-a-service (PaaS) makes deployment easy. But which PaaS do you choose and how do you get started? This talk will examine several of the leading PaaS providers and discuss their pros/cons. We'll also give examples for how to deploy the same app to each of them to see the differences.

We'll take Mezzanine, a popular Django-based CMS and show how to deploy it to the leading PaaS providers. I'll show example config files for each provider, and what code was necessary to change to get it to deploy. Particular pain points we'll cover are how to deal with static assets, options for caching, how to handle database migrations while minimizing downtime, and import/export of data. We'll wrap it up with a comparison with pros/cons of each provider, and what features each supports.

???

Building a stdlib for Django deployments on top of fabric

fabric is great ... as far as it goes. But you still have to write quite a lot of code yourself - and then test it and debug it. Wouldn't it be great if you could use a well tested library of code that knew about version control and your web server? Even better if the same code is used both to bootstrap your development environment and set up your server.

We've been building such a library and have used it across quite a number of Django projects, learning and improving as we go. I'll take you through the settings required and the use cases it can handle for you.