Welcome Session

I'll be proposing a new category of code contributor I'm calling "Code Contributor Mentor", and also enumerating the need to recognize, recruit & support non-code contributors.

In my presentation I will talk about how powerful django.contrib.admin really is. This is the first part of a series of presentations. For beginners and advanced developers.

Property-based testing is a great benefit to the robustness and maintainability of your software. Yet, the technique is still vastly underused in the Python community. The workshop gives a hands-on introduction to Hypothesis and practices different approaches for writing property-based tests for Django applications.

File-system based routing has been widely used in JavaScript web frameworks
such as Next.js, NuxtJS, Remix, Gatsby, and SvelteKit.

With file-system based routing, the URL structure of your web application
is defined by the structure of the codebase. This makes it easier to find the
view that handles a certain path, and vice versa.

This talk will explore an experiment that implements file-based routing in a Django project.

Passwords alone can’t protect us. We need multi-factor authentication, which doesn’t come with Django out of the box. But we can add MFA to our Django projects in just a few minutes, giving our users the ability to protect their accounts with Touch ID, security keys, and one-time passwords.

This workshop will teach you how to create a production ready GraphQL API using Python and Strawberry. We will be using using Django as our framework of choice, but most of the concept will be applicable to other frameworks too.

We'll learn how GraphQL works under the hood, and how we can leverage type hints to create end to end type safe GraphQL queries.

We'll also learn how to authenticate users when using GraphQL and how to make sure our APIs are performant.

If we have enough time we'll take a look at doing realtime APIs using GraphQL subscriptions and how to use GraphQL with frontend frameworks such as React.

Django Ninja is the quickest way to build REST APIs, that will be fast, secure and documented automatically.

This talk ties the core components of what makes a good Django/Python/whatever developer into activities that can affect billions of people. The volume of lives affected raises ethical questions, for as Ian Malcolm says, “Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.”

Django's ORM is probably the most powerful feature of this framework. This talk is about how queries to the database are internally translated into SQL with Query objects and how to hack that process.

In the modern JavaScript landscape, component-focused UI frameworks are the norm. We’ll look at how the team behind Wagtail brought component-driven development from React to Django templates with Storybook, speeding up the development process and simplifying maintenance of large pattern libraries.

Over the last year, the Diátaxis documentation framework has taken off in popularity. This workshop provides a brief introduction to the framework, and includes a number of hands-on exercises.

How we extricated ourselves from a world of thorny, slow developer onboarding and daily MacOS Docker-compose file sync performance issues. And how you can too.

Learn about modern JavaScript through a practical example. We will build a Vue.js application from scratch: a note taking app for DjangoCon. This will give us some much needed context to help us learn about modern JavaScript, its ecosystem, the frontend frameworks and more.

Data isolation is key when working with bounded physical tenants like grocery stores. All the APIs and data are tenant dependent and we don't want to mix them between stores. This is the tale of the yellow brick road to multitenancy and how a Django project hack became an open-source library for everyone to use. The hack behind the curtain, welcome to Oz!

Lightning Talks

Morning Announcements

As a Django developer, there are things you need to worry about. Keeping up to date with Django trends and best practices is one thing, but what about all the other parts of technology that are incessantly advertised towards you? What should you have to worry about?

PyScript hit the community like a storm after its announcement and becomes the top trending project on GitHub. It allows the running of Python on the browser. But there’s still some misunderstanding of it. Will it replace all web frameworks? What you can or cannot use PyScript for? Let’s find out.

The Django framework makes it really easy to use Python classes for our data structures and from thereof create forms together with their editors. However, the usability of forms created the Django way have a huge potential to improve their usability. In this talk I will show how to achieve this without the need for JavaScript frameworks and with minimal changes to the existing code base.

We love writing Python. Yet, sometimes, its performance is not ideal. Instead of going to use C let's use Rust instead.

Stop dealing with giant PO files when trying to achieve i18n on your website and start managing them better.

If something is hard to do, you’re unlikely to do it as often as you probably should. Development environments are no exception. How many people on your team have the skills and experience to create staging environments to assess performance and new features?

We have a lot of great tools to help us develop Django applications, from tests to the Debug Toolbar. But what happens once you deploy your code to production? In this talk we will go through the options and best practices to make your production environment as friendly as possible.

Dogs wag their tails, and when the opposite happens, it represents distorted priorities and a disturbing, problematic reversal of the proper order. But not when it comes to software and its documentation! I believe that the tail of documentation can and should wag the dog of software, and I'll show just how powerful this tail can be.

Server-side is back, baby!

- take a break from Javascript, write your apps with liveviews instead 🚀

In this tailk, we explore liveviews as an alternative to “traditional” client-side rendering – a new way of building dynamic user interfaces for the web.

First, we give an introduction to the concept of liveviews and discuss how it differs from server-side rendering and client-side rendering.

After that, we showcase our interpretation of a Django liveview called Hypergen.

Then, in the main part of the talk, we build an example app with Hypergen while discussing some of its architectural choices.

Last, we open for questions and a more interactive vibe.

So are you looking for a break from Javascript, or if you’re just curious about what else is possible with Django, this talk is for you!

Writing tests is notoriously cunning - you can do a lot of busy work with little impact on the overall project quality.

In this talk, we will slice our Django app in different layers, in order to identify the testing sweet spot, in each of those layers.

The final goal - to test what actually matters!

Can you predict lightning strikes using Django and AWS? Yes! Learn how to take an algorithm and idea from a Jupyter Notebook to production ready and cloud native.

As a developer you may have little or no training in database administration, yet you want to design applications that interact with databases in the best possible way. This workshop aims to answer all the questions you wanted to ask your DBA but didn't because he/she is too ~~grumpy~~ busy. You will come away with enough information about databases in general, and about PostgreSQL in particular, to sound like an instant database expert (and, more importantly, to create better applications).

We took the plunge and replaced the 2-year-of-work React UI of our SaaS product with simple Django templates and htmx in a couple of months. We’d like to share our experience with you, with concrete indicators on various aspects, and convince your CTO!

This tour of Django's codebase will explain how Django's magic is implemented, covering some of its metaclasses and other special techniques.

TDD is a software design methodology that is based on first writing tests, then writing source code that successfully passes those tests, and finally refactoring the written code.

At the end of the workshop, you will leave knowing which are the steps to follow to make Django API developments with the TDD methodology and be able to apply what you have learned.

How to test complex objects using the library factory_boy. The lessons I’ve learned using the tool in a Django monolith containing 230+ tables and 75k+ relevant lines of code for over 3 years.

Lightning Talks

Morning Announcements

There’s a lot of excitement about Django going async in 3.0+ but also many questions. This talk will provide a brief introduction to async, cover its pros/cons, and show how to build async into your Django app.

Have you ever wondered what Cross-site Request Forgery is all about? Did you solve your CSRF problem in your single-page application by copy-pasting something from StackOverflow or decorating all your views with csrf_exempt without knowing what these things are actually doing? If so, this talk is for you.

As a Python library author, how do you ensure interoperability with every Python (and Django) version? In this talk, learn how to run your test suite in hundreds of different environments as fast as possible using Pytest, Tox, and GitHub actions.

Django is very good for getting things started & get going, but when it gets thrown into a highly concurrent & high scale environment then real issues start coming up, and you are often left with your head-scratching as to what is happening & how to deal with it; this talk will discuss some of the issues around concurrency & scale in Django & how did we handle it.

In this fun and interactive workshop you’ll identify your Top Two Values and how they simplify EVERYTHING.

Our feedback on integrating some DDD tactical patterns in OSIS, a long-term open-source project for UCLouvain university.

A discussion of how open source software projects are managed, through the lens of an eventually-popular open source software project.

Check all milestones of multilinguale Project in 60 min.

Data-Oriented Design focuses on how software transforms specific inputs to specific outputs, on specific hardware. This talk will cover how this way of thinking can inform writing Django code.

Reading and understanding existing code is a big part of work as software developers. We're constantly exploring code that we did not write and are not familiar with. Yet the tools we have for this frequent task leave a lot to be desired. In this talk we explore how we can use runtime inspection and Kolo to observe what our Django app is doing while running and how that can help us rapidly build a strong mental model that we can then draw on when writing new code.

The natural backend for Django is an OLTP database (MySQL, PostgreSQL), but a growing number of people and companies insist on having a mainly OLAP backend for Django (like Snowflake) . This is a talk on why and the remarkable progress so far.

We discuss financial sponsorships in open source project, from the point of view of open source maintainers: When and how to introduce sponsorships, what to offer, how to make it easy for companies to pay, and how to get paid as a maintainer.

In this workshop we will learn how to create automated integration tests for a REST API using ScanAPI. We will learn how to configure the library, to define the endpoints to be hit, the expected behaviors for each response, how to run the tests and how to access the generated report - which might be used as the API documentation itself.

Discussing why the Django Software Foundation exists, what it does, and ways it may evolve over the next decade

Lightning Talks

Closing Session