Talks and speakers
- Amjith Ramanujam : Introduction to Docker
- Andreas Pelme : pytest: helps you write better Django apps
- Andrew Godwin : Good schema design - and why it matters!
- Angel Ramboi : Gamers do REST
- Aymeric Augustin : Where the Wild Things Are
- Benoît Bryon : Healthchecks for Django
- Bruno Renié : Visibility for web developers
- Christophe Pettus : Really, Really Fast Django
- Daniele Procida : The programmer's body
- David Winterbottom : An introduction to django-oscar
- Frank Wiles : Frequently Missed Performance Gains
- Harry Percival : Don't be scared of the lava! Why purist unit tests are a waste of time.
- Honza Král : From __icontains to search
- Idan Gazit : Advanced Web Typography
- Ilja Bauer : The Power of Natural Language - From ATDD to Lean Modeling
- Jacob Burch & Jacob Kaplan-Moss : Django minus Django
- Jacob Rief : Make AngularJS play nice together with Django
- Julia Elman : Getting RAD with Django
- Kevin Van Wilder : Your Product is more than the Application!
- Leonardo Giordani : Django class-based views: survival guide for novices
- Marc Tamlyn : The future of PostgreSQL in Django
- Mathieu Leplatre : Team up Django and Web mapping
- Meghan Reilly : Introduction to User Experience Design
- Raphaël Barrois : Designing and maintaining distributed systems
- Richard Moch : Open data on the sea shore
- Samuel Goldszmidt : Migrate a web application to Django
- Sneha Priscilla Makini : The Whys and Hows of using Django Formsets
- Ustun Ozgur : Taming Complexity with Django
- Xavier Dutreilh : Web components in Django
- Xavier Fernandez : Harness the speed of the wheel
- Yann Malet : Challenges when building High profile Editorial Sites
Introduction to Docker 45mn
Docker is an open source tool that simplifies managing Linux containers. A container is a sandbox environment that runs a collection of processes. Containers are light-weight VMs that share the same kernel as the host OS.
Docker adds some niceties to Linux containers such as AUFS, version control, docker registry (repository), versioning etc. This talk will serve as an introduction to working with docker tools. I'll cover the basic concepts behind docker and explain the difference between a docker container and a VM. Show a demo of how easy it is to create a docker image and launch a container from it. Briefly explain the idea behind Dockerfile and show some examples.
I'll cover how networking and filesystem changes are handled in Docker. Show a demo of how to deploy a Django application in docker and explain why it's useful to do so in production.
I'll also cover some common use cases of docker in the industry such as testing, deployment, PAAS etc.
pytest: helps you write better Django apps 45mn
Pytest is a full featured testing tool that can make your testing experience better. This talk will introduce you to pytest and show how easy it is to get started with pytest in your own project.
Good practices are crucial to effective testing. This talk will cover Django testing best practices with a lot of concrete examples. It will also discuss how to write faster tests and how to improve test run time by running tests in parallel.
Good schema design - and why it matters! 45mn
Pretty much every website is underpinned by a database or two - and how you're storing data in there really matters. This talk will cover the best ways to set up your schema to store your data, how to change your schema without any downtime, and how to use the brand-new migration features in Django 1.7 to your best advantage.
We'll take a look at database normalisation (and why it's not always a good idea), denormalisation, schemaless data, how to best set up your tables and indexes for different load types (heavy read/heavy write/balanced), and how to scale up your database and its schema as you grow.
Gamers do REST 15mn
The presentation is meant to give an overview (sprinkled with implementation details and solutions to issues we encountered) of how we use Django to build RESTful APIs in Demonware and how we manage to reliably serve millions of gamers all over the world that play Activision-Blizzard’s successful franchises Call of Duty and Skylanders.
Topics the presentation will touch (some only briefly because of time constraints): - tech stack overview - API design - configuration handling - middleware usage for logging, metrics and error handling - class based views and resource representation
Where the Wild Things Are 45mn
The concept of pluggable applications has been instrumental in the development of the Django ecosystem and the quality of Django websites. But it's bare-bones: the INSTALLED_APPS setting simply contains a list of Python packages.
In February 2007, Joseph Kocherhans uploaded a patch to allow changing an application's label and providing a verbose name for the admin. The scope of this ticket quickly escalated. Eventually it became known — and feared — as "app-loading".
With every ticket closed as a duplicate, the monster grew stronger and hope faded. Valiant efforts by contributors and core devs cornered the beast into a cave but hardly weakened it. It was finally slain in Django 1.7.
Judging by the releases notes, the results are underwhelming. Worse, they come with an annoying list of backwards-incompatibilites. What was that all about?
Healthchecks for Django 15mn
Once you deployed your project, how do you validate everything is running as expected? Then, at runtime, how do you check your site status? Or when an error occurs, how do you examine system? How do you distinguish between bugs in code, issues in configuration or failures in third-party services? That is what healtchecks are made for.
"Hospital" is a healthcheck framework for Python. Let's discover how smoketests and diagnosis can secure your work. Let's see how easy it is to integrate healthchecks with Django (or with any Python project), then plug the results to supervision/monitoring tools.
Note: did you notice Django 1.7 introduces a system check framework? Do you know about django-health-check, django-doctor or django-smoketest projects? We will also consider how authors are trying to make those projects converge.
Visibility for web developers 45mn
Understanding how a site behaves outside of the developer's machine is extremely important. Gathering metrics and events in a production system lead to a better knowledge of pain points and eases troubleshooting a lot when issues arise. This talk will explain how to setup a rock-solid visibility stack for your apps, how to feed data into it and how to extract meaningful information from that data.
We will start with the basics of exception handling and continue with the meat of this talk consisting in two parts:
1 - Events (i.e., mostly logging calls)
An introduction to logging in large production deployments:
- centralized logging with logstash and elasticsearch
- the case for structured logging
- rich dashboards with Kibana
2 - Metrics
An opinionated take on monitoring:
- Riemann, the universal metrics hub
- simple thresholds and alerts
- persisting metrics data to Graphite
- Riemann and Graphite dashboards
Really, Really Fast Django 45mn
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.
- Schema/model design
- Efficient view function design
- Template design for high performance
- Database tuning and sharding
We’ll also discuss caching.
The programmer's body 45mn
What is the only thing that really matters?
We are programmers, and everything in the ideology of our industry is disembodied and virtualised. At the same time we are building the world that the rest of the world, increasingly, will live in.
We are, it seems, sexless selves and disembodied minds in a world that doesn't need our bodies and isn't very interested in them.
And yet: the body remains at the centre of the world, even this supposedly bodiless world. Its disputes and politics, its hurts and controversies, its pains and insults all belong to the body.
Even the fiction and film of this new world of the unbodied are (and always have been) bodily-fixated.
In short, there's no escaping the body.
In this talk, I take examples from history, literature, film, poetry and other fields to show how our present state can be woven into a very ancient pattern, and ask: what should we, as programmers, do about it?
And finally, I make a modest attempt to answer that question.
An introduction to django-oscar 15mn
Oscar is a Django e-commerce framework designed for flexibility. It employs a range of techniques that allow developers to customise any part of the core. In this way it can be used to capture a wide range of e-commerce requirements.
This talk will examine the key techniques used by Oscar that allow this customisation, as well as the features Oscar offers and what it can be used for.
Frequently Missed Performance Gains 15mn
Premature optimization is bad, but there are several things people often overlook that can easily speed up your Django sites that require little to no work and don't overly complicate your development efforts. We'll talk about:
- cached templates
- dealing with sessions
- ORM tips
- front end performance
Small things can make a big difference!
Don't be scared of the lava! Why purist unit tests are a waste of time. 15mn
The "purist" approach to unit tests says that your tests should be perfectly isolated, that they should mock out any dependencies, and that they should never, ever touch the database. The database is hot lava!
In this talk I will outline a (controversial) thesis: that such tests are just not very useful in the world of web application development, and Django. Given that my opinion is so wrong-headed (or maybe just plain wrong), I will endeavour to provide a balanced picture of the pros and cons of different testing approaches, including the arguments for purist unit tests, the options for integration testing and acceptance testing, the "functional core imperative shell" pattern (AKA hexagon architecture), all with a view to leaving the audience informed enough to make their own decisions about testing strategy.
From __icontains to search 45mn
Good search experience for your users is about more than just a more efficient way to find models containing certain word or phrase. In this talk we'll go through what are the relevant parts of search and how to best implement them (we'll use Elasticsearch for actual examples).
We will start discussing data modelling, moving on to simple search, add facets for easier navigation and discoverability, spell checking ("did you mean?") and auto-complete. In the remaining time we'll see about possibilities for further enhancing your search by tracking user searches or providing stored search functionality.
Advanced Web Typography 45mn
Oliver Reichenstein famously quipped that “The Web is 95% Typography.” Most of the information we take in on the web is textual in nature. It behooves us, as writers and curators of text, to know about the art and science of presenting textual information.
This talk isn’t about art, or science, but technique. Typesetting has a rich history, dating back to Mr. Gutenberg and his printing press. Although digital type is fairly mature by now, type on the web is still very much in its infancy. We are only now gaining typographical controls that the publishing industry has taken for granted these last 20 years. I'll be taking you on tour of the current state of type on the web: what we can do today, and what we will be able to do tomorrow.
The Power of Natural Language - From ATDD to Lean Modeling 45mn
Delivering high quality software solutions that meet customer expectations and requirements is the essential goal of any development project. Therefore, development teams need to obtain the relevant domain knowledge and information from their customers.
As a result, initial system specifications are typically formulated using natural language (e.g., within plain text documents). The main challenge imposed by this process is to avoid misunderstandings, misinterpretations and inconsistencies during the transformation of informal requirements into formal specifications, models, and executable code or tests.
At first the talk will briefly introduce Acceptance Test-Driven Development (ATDD) as a powerful method to bridge the gap between requirements engineering and software testing. Following this, the second part will push the original ATDD idea even further by introducing the concept of “Lean Modeling”, a lightweight and pragmatic alternative to classical software modeling and DSL tools.
Examples will be presented that illustrate the usage of natural language specifications for various django specific artifacts:
- REST Resources
- initial database data (fixtures)
This approach can also help to improve our debugging experience and IDE smart completion support. In addition to these advantages during development a demo will be shown, that illustrates how customers / users can benefit from “Lean Modeling” by creating custom forms in their django backend with natural language.
Django minus Django 45mn
Django is a monolithic framework -- or is it? Django prides itself on being "batteries-included," but that doesn't mean you need an appointment at the Genius Bar to replace them. This talk aims to show the audience how to replace every facet of Django, from the template engine to the ORM. The talk will also highlight the areas of Django that still carry this difficulty, and offer direction where Django can go to fix them.
Make AngularJS play nice together with Django 45mn
In my proposed talk, I would like to give a short introduction into AngularJS’s two-way data-binding, which can dramatically reduce boilerplate code, otherwise required when using jQuery. Furthermore, this talk will handle the following topics: - How to render model-bound forms for AngularJS, using mixin classes to be added to the built in Django form. - How Django’s form validation can be used to pre-validate the form data on the client, using the AngularJS Model controller, but without duplicating code. - How to securely call Django view’s methods from inside an AngularJS controller, with a behaviour similar to remote procedure calls. - How to use dependency injection to separate concern for external data, either created by Django for production use, or by a mocking class when writing unit tests for browsers code. - Three-way data-binding build on top of AngularJS’s two-way data-binding using websockets for bidirectional synchronization of the browsers view model with server side data buckets.
In-depth documentation on the topics of the proposed talk can be found here: http://django-angular.readthedocs.org/en/latest/ http://django-websocket-redis.readthedocs.org/en/latest/
Getting RAD with Django 15mn
When working with Django, there are many ways to get from initial idea to final product. Being the framework "for perfectionist with deadlines", the core principles of Django are for working in a fast paced environment. Yet how do we create seamless workflows for team collaboration? What are the optimal project configurations to be able to rapidly create and iterate on your Django projects?
This talk outlines how to leverage the concept of rapid application development (RAD) practices in Django. We'll explore various tools, tips and techniques on how to use rapid development to create a successful finished product.
Your Product is more than the Application! 45mn
All too often we see developers and system operators fail to communicate. Both teams seems to have different requirements: developers want new features and releases whilst operators want stable systems. But the fact of the matter is that both teams have the same goals. When both teams are brought together from the get-go, you notice the goals become visible again and the requirements align.
The Devops movement in IT is a critical mass of developers and IT operations aligning their ideas. It is a collection of best practices, tooling and a philophy that emphasizes on collaboration and automation. But the most important best practice a developer and IT operator requires is the art of clear and concise communication.
In this talk, I'll finally remove the confusion of what Devops really is and explain the best practices and toolsets. The talk revolves around the CALMS acronym:
- Culture: people and process first, if you dont have the correct culture, all attempts will be fruitless.
- Automation: remove the human error from the equation.
- Lean: learn to adapt to situations, think outside the box and identify processes that are a waste of time
- Measurements: If you can't measure, you can't identify and improve. Performance metrics, process metrics and even people metrics!
- Sharing: This is the loopback in the CALMS cycle. Share your ideas and solutions with the community. Learn from the advise of other people and improve your own processes along the way.
Your product is more than the application, it is also the monitoring, the infrastructure, the constant improvement, the sharing of knowledge and the people developing it!
Django class-based views: survival guide for novices 45mn
Are you a Django novice, confused by words like class-based views, URL dispatchers, HTTP requests? Are you still wondering how to use all those things to build the pages of your Web site?
Django programmers that started with versions prior to 1.3 are used to deal with views as functions, and they learned how to process even complex forms in a procedural way. From the release 1.3, Django introduced class-based views (CBVs) and ported its powerful generic views to this new paradigm (class-based generic views, or CBGVs).
This change, however, has not been harmless for Django novices: the django-users mailing list and StackOverflow are full of questions about views and classes.
This talk aims to lead Django novices to a good understanding of what class-based functions are and how they can be effectively used.
The main topics are:
Python classes: how OOP concepts improve the View part of Django MVT. This part aims to introduce Python classes as data processors and explains how OOP concepts like inheritance help the fast development of customized solutions.
URL dispatchers: how Django CBV process URL parameters. Here I discuss how Django class-based views store arguments extracted from URLs and how we can access them.
HTTP verbs: how Django CBV deal with GET, POST and friends. This part shows what happens to a class-based view when HTTP requests are processed and how to leverage the mechanism to customize data processing.
CRUD operations through Django generic class-based views. Create, Read, Update, Delete are the fundamentals operations you need on data, so it is worth learning to use and customize the powerful generic views of Django that implement them.
The target of this talk are Django novices who completed and understood the Django tutorial. Previous knowledge of the basic Python OOP syntax and concepts is preferred (classes, inheritance, method overriding, function arguments processing).
The future of PostgreSQL in Django 45mn
Postgres is awesome, and has loads of lovely features which some other databases do not. We're going to make the ORM better for them.
Team up Django and Web mapping 45mn
Team up Django and Web mapping
A few steps from the Django universe towards the world of cartography!
During this presentation, I will present the basic notions of geographical data, throw light on the dedicated components available in Django, and introduce a couple of frontend tools for Web mapping.
If you wonder how to build maps with Django, how to get rid of Google Inc., or how to draw geometries in Django forms, this talk will take you to the next level!
Introduction to User Experience Design 45mn
While User Experience Design (UXD) may seem like another buzzword, it actually has deep roots in usability, visual design, information architecture, and many other areas that developers and the like may already be familiar with. UXD is not just another process, but instead a way of thinking and collaborating that should not be overlooked for cost or time reasons.
As companies continue to put more pressure on their employees to do more with less, decision makers, product managers and developers are looking for ways to solve problems quickly, while still getting high value for the company and their customers. With changing technologies, strategies and markets, and a constant push for employees to wear multiple hats and work more collaboratively, having an amazing user experience is becoming a "must have" for companies that want to remain competitive.
Developers, product managers and decision makers who are new to UXD and curious to learn more will walk away with a clear definition of User Experience Design, a knowledge of its goals and the basic components that make up a UX project, such as: User Research, UI Design, Front End Development, and Content Strategy. Attendees will also walk away with examples of how UXD can add value to a project for both the business and the users.
Designing and maintaining distributed systems 45mn
As projects grow, they tend to mutate into complex, monolithic applications ; that's where the team splits them into loosely coupled modules talking over the network (a.k.a a service-oriented architecture).
This talk will focus on a few key points for a successful "monolithic to distributed" transition:
- Setting clean and logical boundaries between services
- Providing a seamless integration to service users (SSO, merging views, ...)
- Performing a smooth transition when a service turns remote
- Choosing suitable protocols for communications (spoiler alert: avoid SOAP/XML :p)
- Stubbing versus integration testing, tips and tricks
Open data on the sea shore 15mn
Although data mining for the weather forecast and the sea is well known and organised, the availability to the general public or data mining by volunteers is recent. Sources are varied and may be issued from free software people or volunteer communities, public data or industry. This presentation will aim to draw up a balance sheet of available data, mainly in France and the Mediterranean sea and also what can be done with this data and perspectives within the context of sailing navigation.
Migrate a web application to Django LT (5mn)
This Lightning Talk address the issue of the migration of a web application (eg old PHP + database website) to the Django framework, by proposing a method and some good practices to avoid wasting time. This talk is for beginners.
The Whys and Hows of using Django Formsets 15mn
Are you having trouble choosing the right design approach for handling multiple forms on the same page? Do you end up writing large quantities of code to deal with a dynamically changing set of forms? If so, Django Formsets is the perfect life saver for you!
Most new Django users are intimidated at the idea of Formsets and more often than not, this flexible feature goes unnoticed! This talk will cover the following topics: - Where exactly does one use Formsets and how? - Dealing with dynamically changing forms. - Views & Formsets. - What are the most common roadblocks and what to do about them?
I will also cover how Formsets helped me code GNU Mailman's user settings management feature to handle mailing list settings for a multiple-users multiple-lists scenario.
Taming Complexity with Django 45mn
In the influential paper "Out of the Tarpit", Moseley and Marks argues that "complexity is the single major difficulty in the successful development of large scale software systems". In this talk, we will analyze the major sources of "accidental" complexity a Django project faces over time, and what the major methods to deal with them are. The major tools we have in reducing complexity are reducing state and increasing abstraction skills.
The talk will start with generally accepted methods in Django software development and touch on separating a project into multiple apps, relying on managers to implement collection level functionality, making use of decorators for cross-cutting concerns and adding methods to models (but bewaring the perils of fat models). We will discuss how to separate the roles of models with mixins so that functionality can be reused across models. We will discuss how functional programming techniques can be employed in a Django project to reduce complexity.
Web components in Django 45mn
Django is by far one of the best frameworks to build web applications. However, it suffers from the lack of efficient tools to create good front-ends. So, we often end up writing a lot of ad-hoc codes without any methodology, and using a ton of ready-to-use libraries. Alas, this way of designing front-ends is a terrible idea and we need to engineer these things properly.
In this talk, I will introduce you to the core concepts of web components and their suitability in modern web applications. Then, I will show you the methodology to build them and the tools that you need to use. Finally, I will describe you the process to integrate them into a Django project.
Harness the speed of the wheel LT (5mn)
A quick lightning talk to expose the configurations to use to speed up the creation of new virtualenvs. Typical example will be lxml. Basic install of lxml takes ~40 seconds which goes down to 4 seconds with the correct pip configuration.
Challenges when building High profile Editorial Sites 45mn
This talk will be a walk through the challenges encountered when building a high profile editorial sites. My goal is to present some of the common pitfalls we have encountered at Lincoln Loop and to explain how we solved:
- Legacy migration always take longer
- Multiple environment
- Easy deployment
- Responsive design impacts the backend
- Journey of an image
- Danger of reusing published django applications
- Caching strategy
- Html fragment
Audience Decision maker that are going to rebuild their magazine Developer bidding for this kind of projects for the first time