1.0.0 djangocon-us-2023 2023-10-15 2023-10-20 6 00:05 https://pretalx.com America/New_York Tutorial Track A Tutorials 2023-10-15T09:00:00-04:00 09:00 03:00 Seamless Postgres Query Optimization is a methodology that allows every backend engineer, even without deep database knowledge and 10-year Postgres experience, to move step-by-step to find and eliminate the worst bottlenecks in any SQL. djangocon-us-2023-28693-seamless-postgres-query-optimization Deep Dive Nikolay Samokhvalov en There are two types of Postgres query analysis: - "Macro": analyzing the workload as a whole (three major approaches: using metrics provided by pg_stat_statements or similar, log analysis with pgBadger or similar, and sampling of pg_stat_activity) - "Micro": diving into details of single query execution (EXPLAIN command being the central tool here) And there are huge gaps between them that become noticeable at scale. The main challenges: - Switching between "macro" and "micro" without a huge overhead - Verifying optimization ideas reliably - Deploying changes risk-free - Solving these tasks at a scale requires advanced DBA experience and–sometimes–intuition. Or better tools that (fortunately!) very recently started to appear. In this tutorial, we will learn how to establish a smooth and seamless SQL optimization process in your organization: * what tools should you choose in your particular case? * how to close the gaps mentioned above? false https://pretalx.com/djangocon-us-2023/talk/GJJK8C/ https://pretalx.com/djangocon-us-2023/talk/GJJK8C/feedback/ Tutorial Track A Tutorials 2023-10-15T13:00:00-04:00 13:00 03:00 We'll look at creating a Python and Django specific developer environment in VS Code including all the extensions, settings, and new features that will make developing your Python project simpler. This workshop is tailored to your needs for you to take home to your development teams. djangocon-us-2023-31953-collaborative-supercharge-your-python-and-django-development-environment-with-vs-code-and-dev-containers General Dawn Wages en Dev Containers is an open spec, full-featured development environment, built on Docker, a well-defined tool and runtime stack, with the power of your favorite editor inside. We will share tips, tricks, tools and settings for VS Code, the light-weight, free and extensible code editor, to optimize your Python activities from app development to data wrangling. Walking out of this tutorial, you will have: - your own, personalized profile(s) in VS Code for your workflow(s) that can include specifications for linters, terminal, type hinting, tasks, debugging, VS Code shortcut keys, creating snippets, and virtual environments. - a peek into the best VS Code Extensions for Django and Python development: Ruff, Jupyter Notebook, Data Wrangler, Remote Development extension pack, SQLTools and PostgreSQL, and more. - set up Dev Containers and CodeSpaces for an existing Open Source project or set it up for your project with all of the slick features including navigating your database and integrating with GitHub actions. false https://pretalx.com/djangocon-us-2023/talk/RUDEUX/ https://pretalx.com/djangocon-us-2023/talk/RUDEUX/feedback/ Tutorial Track B Tutorials 2023-10-15T09:00:00-04:00 09:00 03:00 Test Driven Development (TDD) has become a widely used methodology in software development to ensure code quality and minimize bugs. In this workshop, you will learn the fundamentals of TDD and its benefits, along with practical tools like factory_boy and faker for pre-populating data factories in tests. You will also learn how to write tests for Django REST endpoints, mock 3rd party services, and parameterize tests for different user types and roles. By the end of this workshop, you will have a solid understanding of TDD and the skills to implement it in your Django projects. Whether you are a beginner or an experienced developer, this workshop will provide valuable insights and techniques for mastering TDD in Django. djangocon-us-2023-28833-mastering-test-driven-development-in-django-a-comprehensive-guide-with-factoryboy-and-faker Deep Dive Kuldeep Pisda en In this workshop, we will learn the followings: 1. What is Test Driven Development (TDD)? 2. The benefits of TDD 3. Introduction to `factory_boy`. 4. Using `faker` to pre-populate the data factories in the tests. 5. Writing Tests for the Django REST Endpoints 6. Mocking the 3rd party services in the tests 7. Parameterizing the tests After the workshop, you can understand and follow the TDD approach in your Django Project. You can pre-populate the Django factory models with `factory_boy` and `faker.` In the Django project, you can write tests for different user types/roles and tests for very simple to very complex test cases. false https://pretalx.com/djangocon-us-2023/talk/Y3TPJT/ https://pretalx.com/djangocon-us-2023/talk/Y3TPJT/feedback/ Tutorial Track B Tutorials 2023-10-15T13:00:00-04:00 13:00 03:00 Fully static sites have clear benefits – and limitations. Rather than going fully static, let’s use Next.js in combination with a Django/Wagtail API backend, so we make the most of both platforms. djangocon-us-2023-32295-best-of-both-worlds-next-js-wagtail General Meagen Voss en In the JavaScript world, a new breed of frameworks are reinventing how websites are built and hosted. With Next.js, you can create sites that are both static and dynamic across different routes, rendered client-side and server-side, all with one framework. You don’t have to switch over fully to JavaScript to benefit from those innovations. In this workshop, we’ll combine Next.js with Wagtail, a tried-and-tested CMS based on Django. We’ll get the best of both worlds: the delight of Python in the backend for business logic, and the advanced dynamic UIs powered by React. In this workshop, we will cover: - Initial project setup for Next.js and Wagtail - Connecting Next.js to the backend via a GraphQL API - Implementing common website requirements in this architecture - Deployment! Aside from an initial introduction, all steps of the workshop will be hands-on. We expect attendees to come with Node and Python installed on their system, and to already have some experience with Django and JavaScript. No pre-existing knowledge is required for Next.js, React, Wagtail, GraphQL. false https://pretalx.com/djangocon-us-2023/talk/789MCP/ https://pretalx.com/djangocon-us-2023/talk/789MCP/feedback/ Tutorial Track C Tutorials 2023-10-15T09:00:00-04:00 09:00 03:00 Ref: https://xkcd.com/2054/ As data-driven organizations grow, life gets... complicated - data pipelines requirements grow - more data sources and sinks are added to the mix - tasks become dependent on each other in complicated ways - service agreements need to be adhered to and monitored - schedules need to be maintained... Apache Airflow, initially developed and open-sourced by those nice folks at Airbnb, solves these problems and more. In this tutorial session, we'll be starting off by getting to grips with Airflow as a stand-alone tool, and then we'll see how we can get it to play nice with Django. djangocon-us-2023-31990-django-3-airflow General Sheena O'Connell en It would be useful if attendees were familiar with Django coming into this session. No prior experience with Airflow is needed. What we'll cover: - What Airflow is all about and what kinds of problems you could use it to solve - Airflow development setup - Getting to grips with Dags and operators - Integration with Django false https://pretalx.com/djangocon-us-2023/talk/WWY3EP/ https://pretalx.com/djangocon-us-2023/talk/WWY3EP/feedback/ Tutorial Track C Tutorials 2023-10-15T13:00:00-04:00 13:00 03:00 Escape from the dark, complex web of modern application development, and return to the green pastures where Django began - where web application development was simple, fast, and fun. Hotwire allows us to keep using Django's amazing toolkit and all the productivity benefits that come with it, while obtaining the results people expect from a modern website. This tutorial will introduce you to Hotwire and radically change how you thought modern web development had to be. djangocon-us-2023-32023-hotwire-a-refreshing-approach-to-the-front-end-that-keeps-django-the-star General Stephen Mitchell en If you are yearning for the days where a single developer could create a web application, or if you feel strained under the complexity of current web application architecture, this tutorial will illustrate how to breathe freely once again. Hotwire takes a fresh approach to single page app development that allows the backend to remain the star; and that makes it a perfect fit for Django. Django templates are rendered in full, but instead of loading a new page in the browser, the different elements are swiftly replaced in the page. This provides the speed and feel of a single page application, while retaining the development efficiency and tool kit Django provides. This tutorial will cover: * How we got here * Overview of Hotwire (Turbo and Stimulus) * How to think about templates * Common development patterns * Forms * Tabs * Paginated & filtered tables * Javascript sprinkles with Stimulus * Pack it up. Compile and deploy your new code. false https://pretalx.com/djangocon-us-2023/talk/UV3DKA/ https://pretalx.com/djangocon-us-2023/talk/UV3DKA/feedback/ Junior Ballroom 45-minute talks 2023-10-16T11:10:00-04:00 11:10 00:45 You may think the Django ORM is big and scary, but at the end of the day, it's just Python. Join me as I talk about my experiencing fixing an ORM bug with help from the community djangocon-us-2023-30575-contributing-to-django-or-how-i-learned-to-stop-worrying-and-just-try-to-fix-an-orm-bug General Ryan Cheley en We'll start with my experience at DjangoCon US 2022 and the work I did while at the sprints on an ORM related bug. Then we'll walk through the process I went through as I realized that the bug I thought could be closed was actually still a bug and needed to be fixed. I'll talk about the process I used to work on the bug and the great support I got from the community (both in person at Django Con US and online afterward). By the end of this talk you'll realize that while the Django ORM can seem big and scary, and you may be hesitant to try and tackle a bug or other issue related to it, at the end of the day, it's *just* Python. Key take aways: - using public notes as a way to track your learning and progress on (any) issue - getting comfortable with the idea of becoming the world's foremost expert on an issue - getting stuck is OK because the Django community is amazing and supportive and wants to see you succeed in fixing this bug false https://pretalx.com/djangocon-us-2023/talk/XQBHKJ/ https://pretalx.com/djangocon-us-2023/talk/XQBHKJ/feedback/ Junior Ballroom 25-minute talks 2023-10-16T12:00:00-04:00 12:00 00:25 This talk is a love letter to meetups. We'll cover how meet-ups fit into our larger ecosystems, what we could work on collectively to support each other, and maybe even make a plan for saving the world -- one meet-up at a time. djangocon-us-2023-32020-meet-ups-a-grand-vision-for-a-humble-endeavor General Deb Nicholson en Meet-ups are one of the best places to bring new people into our communities, but it feels like each one is constantly reinventing the wheel. What if we thought about running meet-ups as a craft and talked about what we're doing there as one of the most important activities that code communities can engage in? Python and Django have built fantastically welcoming communities, and now it's time go out there and bring in the next wave of community members. This talk is a love letter to meetups. We'll cover how meet-ups fit into our larger ecosystems, what we could work on collectively to support each other, and maybe even make a plan for saving the world -- one meet-up at a time. false https://pretalx.com/djangocon-us-2023/talk/T7UCY9/ https://pretalx.com/djangocon-us-2023/talk/T7UCY9/feedback/ Junior Ballroom 45-minute talks 2023-10-16T14:05:00-04:00 14:05 00:45 BeeWare is a framework that let users of all skill levels develop applications with native user interfaces. It is very powerful to extend the already existing Django application to multiple devices. In this talk, we will demo building a simple Beeware app with a Django backend. djangocon-us-2023-32110-let-s-build-a-beeware-app-that-uses-django General Cheuk Ting Ho en In this talk, we will go through the basics of building a Beeware app. However, instead of starting from scratch, we will assume that we have a Django app that is already built - we will use the first step tutorial on Django documentation. Then, we will start building the BeeWare UI and link it up with the already working Django app. After building our example, we will also discover other alternatives that BeeWare can work with Django so in the future, if you are building another BeeWare app, you can decide which method you want to use. ## Outline - Introduction of BeeWare (10 mins) - Make sure the Django App is running (5mins) - Building the BeeWare UI (10 mins) - Combine with Django (10 mins) - Conclusion and alternatives (10 mins) false https://pretalx.com/djangocon-us-2023/talk/3WSEZD/ https://pretalx.com/djangocon-us-2023/talk/3WSEZD/feedback/ Junior Ballroom 25-minute talks 2023-10-16T14:55:00-04:00 14:55 00:25 Dig a bit into the inner workings of migrations, and learn a bit about more advanced uses for them djangocon-us-2023-32191-beyond-the-basics-of-migrations General Charlotte Mays en This talk will go into the basic anatomy of an auto-generated migration, as well as ways to leverage migrations for more complex functionality, such as data transformation. The goal is to demystify migrations for beginners and to empower intermediate users to do more with migrations. Provisional Outline: - Introduction to basic migration anatomy (~5 minutes) - In brief, what migrations are doing under the covers when run (1-2 minutes) - Editing auto-generated migrations, and what functionality is available (~5 minutes) - Creating a migration from scratch, with an example or two (5-8 minutes) - A few best practices to keep in mind (~2 minutes) - Remaining time for Q&A false https://pretalx.com/djangocon-us-2023/talk/DDLBHS/ https://pretalx.com/djangocon-us-2023/talk/DDLBHS/feedback/ Junior Ballroom 45-minute talks 2023-10-16T15:55:00-04:00 15:55 00:45 In today's world, APIs have become the backbone of many modern applications. Django, one of the most popular web frameworks, along with Django Rest Framework, provides a powerful and flexible platform for building APIs. And when it comes to API documentation, OpenAPI has emerged as the industry standard. In this session, we will dive deep into API development with Django, Django Rest Framework, and OpenAPI. We will explore the capabilities of these tools and learn how to build robust and scalable APIs. We will cover topics such as API design principles, request handling, response formatting, authentication, and versioning. We will also discuss best practices for documenting APIs using OpenAPI. By the end of this session, you will have a solid understanding of API development with Django and Django Rest Framework, and be able to create high-quality APIs that meet the needs of your users. You will also have the skills to document your APIs using OpenAPI, ensuring that your documentation is always up-to-date and accurate. So join us and learn how to build powerful APIs that can transform the way you and your users interact with your application. djangocon-us-2023-31662-building-powerful-apis-with-django-django-rest-framework-and-openapi Deep Dive Velda Kiara en In this session, attendees will be introduced to the world of APIs and learn how Django, one of the most popular web frameworks, can be used to build them. We will explore the capabilities of Django Rest Framework (DRF), a powerful and flexible platform for building RESTful APIs. In addition, we will discuss the benefits of using OpenAPI for API development, and learn how to leverage it to create robust and scalable APIs. We will cover best practices for API design, including request handling, response formatting, authentication, and versioning. Throughout the session, we will focus on building RESTful APIs with Django and DRF, using practical examples to illustrate key concepts. Attendees will leave with a solid understanding of how to design and document APIs using OpenAPI, ensuring that their documentation is always up-to-date and accurate. Whether you are new to API development or looking to improve your existing skills, this session is for you. Join us and learn how to build powerful and effective APIs using Django, DRF, and OpenAPI. false https://pretalx.com/djangocon-us-2023/talk/V87DN3/ https://pretalx.com/djangocon-us-2023/talk/V87DN3/feedback/ Junior Ballroom 25-minute talks 2023-10-16T16:45:00-04:00 16:45 00:25 Hi from Brazil! 👋🏾🇧🇷 Join us for a unique journey from Brazil to the world of Python and Django. AfroPython, initially inspired by community events, has transformed into a social good company. In this talk, we'll explore the evolution of AfroPython and the impact of Python and Django on our journey. We'll discuss how these technologies have enabled us to achieve our mission and create social change. Come and be inspired by our story! djangocon-us-2023-31754-afropython-using-django-to-change-black-people-life-in-brazil General FeliPython (Felipe de Morais) en I'm Felipe de Morais, Co-CEO and co-founder of AfroPython. In this talk, I will share the path of AfroPython in Brazil(http://afropython.org/) and how the Python community was involved in growing and building this community of black people in IT. And how we became a company to help people thrive using Python. false https://pretalx.com/djangocon-us-2023/talk/RTQ9AH/ https://pretalx.com/djangocon-us-2023/talk/RTQ9AH/feedback/ Grand Ballroom II-III 45-minute talks 2023-10-16T11:10:00-04:00 11:10 00:45 Many Python developers who build web applications rely on JavaScript-heavy Single-Page Applications (SPAs) to achieve dynamic user experiences. However, these SPAs have challenges, including increased complexity, slower load times, and complicated build pipelines. But an alternative approach exists that delivers an exceptional user experience without the drawbacks of SPAs! This talk will explore how you can leverage the power of HTMX, AlpineJS, and Django's ability to stream HTML to create web applications with a significantly improved user experience. We will delve into the principles and techniques that make this approach a compelling alternative to SPAs. djangocon-us-2023-32036-html-ivating-your-django-web-app-s-experience-with-htmx-alpinejs-and-streaming-html General Chris May en The rise of SPAs has brought many benefits, but it has also introduced complexity and performance overheads that can be overwhelming. As Django developers, we know the power and elegance of the Django framework, and we believe it can deliver a better user experience without the need for heavy JavaScript frameworks. In this talk, we will dive into the concepts of HTMX, a lightweight library that allows us to update parts of the HTML directly from the server, and AlpineJS, a minimal JavaScript framework for enhancing interactivity. We will explore how these tools can be integrated seamlessly with Django to create modern web apps with enhanced user experiences. Additionally, we'll see how Django 4.2's `StreamingHttpResponse` lays the foundation for better experiences of views that require slow queries, microservice calls, or APIs. ### Key points: 1. Understanding the limitations of JavaScript-heavy SPAs: - Increased complexity and maintenance overhead - Slower initial load times and performance implications 2. Introduction to HTMX: Learn how to leverage HTMX to update parts of the HTML directly from the server, eliminating the need for heavy JavaScript frameworks. 3. Enhancing Interactivity with AlpineJS: Discover how to add lightweight JavaScript interactions to your Django app using AlpineJS, improving the user experience without sacrificing simplicity. 4. Streaming HTML for Performance: Explore how to stream HTML to deliver a fast and interactive experience, even in slow network connections or large datasets. 5. Case Study: Dive into a real-world example of a web app that leveraged streaming HTML to achieve impressive user experiences. By the end of this talk, attendees will be inspired to leverage HTMX, AlpineJS, and streaming HTML to create modern web applications with exceptional user experiences. They will gain insights into the benefits and trade-offs of this approach compared to JavaScript-heavy SPAs and leave with practical tips and best practices for implementing these techniques in their Django projects. false https://pretalx.com/djangocon-us-2023/talk/8ZT8DV/ https://pretalx.com/djangocon-us-2023/talk/8ZT8DV/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-16T12:00:00-04:00 12:00 00:25 Django and Vue both have unique front-end strengths. Django’s context-driven template views offer rapid development of pages directly from back-end model content. Vue’s modern reactive components provide powerful tools for building complex UIs within the rich Javascript ecosystem. Do we have to choose one or the other, or is there a way to combine both front-end frameworks in a single project without compromising their strengths? This talk will demonstrate step-by-step how to intermingle Vue SFCs within Django Templates, such that targeted areas can be enriched with Vue while retaining the flexibility and convenience of Django Templates in the remainder. djangocon-us-2023-31755-vue-django-combining-django-templates-and-vue-single-file-components-without-compromise General Mike Hoolehan en Typical solutions to integrating Django and Vue forgo much of the strengths of one in lieu of the other. For example, a common approach is to use Django Rest Framework as back-end while writing the entire front-end in Vue, making it difficult to utilize Django templates in places it could be expedient. A second approach is to use Vue within Django templates using browser <script> includes, but then lost is the ability to use Vue's Single File Components (SFCs). This talk will explain a unique approach to intermingling Django Templates and Vue that preserves the strengths of both. Starting with a minimal Django project, I will demonstrate the addition of Vue components into a final working app that combines both front-end frameworks. Topics such as information passing from Django to Vue, maintaining Vuex state between pages, and deferred loading of Vue resources will also be explored. false https://pretalx.com/djangocon-us-2023/talk/UJP3PS/ https://pretalx.com/djangocon-us-2023/talk/UJP3PS/feedback/ Grand Ballroom II-III 45-minute talks 2023-10-16T14:05:00-04:00 14:05 00:45 Tracking model history is an essential aspect of many problems encountered in web applications, from simple audit trails to preserving values of fields during state transitions. There are a wide array of approaches to do this with Django apps, almost all of which are subject to performance penalties, require unstructured JSON fields to track history, or can easily be bypassed accidentally in application code. In this talk, we show a new way to to track history in Django with database triggers. We specifically focus on Postgres databases using the [django-pghistory](https://github.com/opus10/django-pghistory) app. We discuss the benefits of using database triggers for history in the context of simplicity, performance, and reliability. We also discuss the benefits of using structured history tables and how this can allow engineers to solve complex history-related modeling problems. Attendees of this talk will be exposed to a totally new way to think about history tracking in their application, along with an understanding of the pros and cons of using database triggers to track history in practice. djangocon-us-2023-32277-using-database-triggers-to-reliably-track-model-history General Wes KendallMaxwell Muoto en Tracking model history is an essential aspect of many web applications, as it allows developers to monitor and analyze changes made to the data over time. In Django, the majority of history tracking apps are implemented in Python at the application level, making a tamper-proof audit trail nearly impossible to implement accurately. By utilizing triggers, developers can automate the process of capturing and storing changes made to models within the database itself. This approach offers several benefits. Firstly, it reduces the complexity of manually implementing and maintaining history tracking functionality in Django code. Triggers provide a centralized and standardized mechanism to monitor modifications, ensuring consistency and accuracy across multiple models and applications. Secondly, triggers enable the tracking of changes at a database level, resulting in improved performance and reduced overhead. Since the triggers are executed within the database engine, they can efficiently capture modifications without requiring additional round-trips between the application and the database. This efficiency is particularly valuable when dealing with large datasets or frequently updated models. Furthermore, triggers provide a reliable and tamper-proof history of model changes. By operating at the database level, triggers can capture modifications regardless of whether they originate from Django or other external sources. This capability ensures that all changes to the model are consistently tracked, eliminating the risk of data loss or incomplete history. Additionally, utilizing triggers for model history tracking in Django promotes data integrity and compliance with auditing requirements. By maintaining a comprehensive record of changes, developers can trace back and analyze the evolution of data, helping to identify potential issues, perform forensic analysis, or meet regulatory obligations. In this talk, we show how to implement history tracking using [django-pghistory](hub.com/opus10/django-pghistory), an app that uses Postgres triggers to track historical changes. We discuss the philosophy of django-pghistory and how it models historical changes so that engineers can use structured history tables that mirror tracked models. We show how users can attach free-form context from the application to group together changes, forming a more coherent audit trail. We also discuss several other application-specific examples of using django-pghistory in practice, for example, using conditional history triggers to track and snapshot specific events. false https://pretalx.com/djangocon-us-2023/talk/EVKSDF/ https://pretalx.com/djangocon-us-2023/talk/EVKSDF/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-16T14:55:00-04:00 14:55 00:25 This talk explores the potential of Django custom model managers and querysets, guiding beginners through their utilization for more efficient and maintainable development, showcasing practical patterns along the way. djangocon-us-2023-32299-custom-model-managers-and-querysets-graduating-from-django-beginner-to-orm-master General Josh Thomas en In my journey as a Django developer, I know the moment when I did not consider myself a beginner anymore: when I started leveraging Django custom model managers and querysets. Initially they can seem intimidating and potentially complex. However, they can help make your use of the ORM more efficient, allow you to encapsulate complex and repetitive queries, and provide an API surface area that makes it easier to introduce certain changes to Model fields and queries, among other benefits. Outline: - A general overview of Model Managers/QuerySets - How to define a custom Manager/QuerySet and either override the built-in one Django provides or add additional ones. - The difference between a custom model manager and queryset and where you may use one over the other - A few useful patterns I keep reaching for: - `.for_user(user)` - filtering a queryset to include only the objects a user has access to - `.with_complicated_legacy_raw_SQL_query()` - when migrating a legacy system to Django, I used this extensively before translating the original raw SQL into Django ORM - `.exclude_some_condition(condition)` - excluding certain objects based on a condition This talk is aimed at beginners and intermediates with a basic familiarity with the Django ORM. Towards the end of the talk, we will dip our toes in more advanced parts of the ORM (annotations/aggregations, subqueries, etc.) to show the potential of custom Managers/QuerySets. false https://pretalx.com/djangocon-us-2023/talk/FHBZXB/ https://pretalx.com/djangocon-us-2023/talk/FHBZXB/feedback/ Grand Ballroom II-III 45-minute talks 2023-10-16T15:55:00-04:00 15:55 00:45 Production server infrastructure is a complicated beast that requires configuring and coordinating dozens of tools and services. You have a new Django application and you're ready to deploy it; what next? You have an existing Django application and you set up the servers yourself; what can you do better? I’m the co-founder CTO of [Zagaran, Inc.](https://zagaran.com), a software consulting company. Over the past 10 years, we’ve built, maintained, and deployed dozens of Django websites, and have an extensive playbook for how to do that well. In this talk, we'll draw from that playbook and go through the main issues for a creating a robust and secure Django deployment. For each issue, we'll look at the technologies and techniques to solve it. We'll focus on AWS as a hosting platform, but the techniques at play will work on any major cloud provider. This talk will cover the following: * Application hosting * Resilience to server failures * Automating deployment * Secrets management * File storage * Error monitoring * Server maintenance * (and more!) djangocon-us-2023-31278-hosting-and-devops-for-django General Benjamin "Zags" Zagorsky en ## Motivation One mistake in a server setup can lead to major downtime or a security breach of a website. Short of that, it can cause a lot of headaches for developers. This talk will cover the key issues that people encounter in creating and maintaining production deployments, and present one or more battle-tested solutions to each of those problems. There are a lot of technologies involved in a good server setup, and the list at first may seem overwhelming. This talk is going to be an overview of the technologies in question. For each suggested technology, the goal is to leave the audience with an understanding of where each technology fits in the deployment ecosystem and what they would be using it for, so they know what documentation to look for when they are working with it. ## Target Audience This talk is aimed at anyone that is working with the servers and/or deployment process of a production Django project. For people setting up a new set of servers for a Django project, this talk should be a good overview of the approach they need to take. For people with an existing server setup for a Django project, this talk should help them identify issues that they had missed and ways to make their servers easier to manage. ## Technological goals A good server setup has the following properties: * Server setup is resilient to individual server failures * Deployments are robust and fully automated * Code can be tested on a representative environment (ex. staging) before being deployed to production * Data and secrets are properly secured and backed-up * Errors are sent to developers * Servers can be analyzed for problems * Resources can be scaled in response to load These properties are the framing for the talk. All the technologies and techniques in this talk serve at least one of these goals. ## Outline The following is an outline of the presentation. Each bullet point roughly corresponds to one slide (on average, one minute of content). Intro: * Who I am * Motivation * Goals of a good deployment * Talk outline Hosting: * Elastic beanstalk * ECS * EKS (Kubernetes) * Terraform * Gunicorn * Docker * Load balancers Deployment: * Deploying EB * Deploying ECS * Deploying EKS * Full continuous deployment (zero-click deployments) * Updating system packages Databases and Migrations: * RDS and backups * Encryption in transit and at rest * Security groups for RDS * Running migrations on EB (configure a deployment command) * Running migrations on ECS (run a task) * Running migrations on EKS (run a job) * Django Migrations race condition * Downtime flag for deployments * Automatic database resizing Static assets and Media: * WhiteNoise plus on-server hosting for static assets * CloudFront for static assets * django-storages + S3 for media assets * Encryption in transit and at rest Secrets management: * django-environ * Amazon secrets manager HTTPS: * Amazon certificate manager * Disabling insecure versions of SSL and Amazon SSL policies * HTTP -> HTTPS redirect Monitoring/Error Reporting: * Sentry (error monitoring tool) * UptimeRobot (uptime monitoring tool) * DataDog (error monitoring plus profiling tool) Performance: * CloudWatch (profiling tool) * NewRelic (profiling tool) * Load testing * Manual scaling * Auto-scaling Extras: * Dependency pinning: use pip-tools or poetry * SSH-ing on to a server: use Amazon Session Manager; for EKS, install Amazon SSM agent false https://pretalx.com/djangocon-us-2023/talk/C7SLH8/ https://pretalx.com/djangocon-us-2023/talk/C7SLH8/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-16T16:45:00-04:00 16:45 00:25 In this talk, we will explore how to work with Neo4j using Python to build scalable and efficient web applications. When we think of databases, the first thing that comes to mind are relational databases like MySQL or PostgreSQL, but there are other types of databases, such as non-relational databases, which are very useful and efficient for various problems. An example of one of these non-relational databases is a graph database, such as Neo4j We will learn how graph databases work, the syntax of Neo4j, how to transform a relational model into a non-relational one with simple steps, and examples of queries using Cypher. We will also take a look at use case scenario using the Django neomodel library. a basic API using Django with the interface neomodel to connect with Neo4j By the end of the talk, attendees will have a basic understanding of how to leverage these technologies to build fast and scalable web applications. djangocon-us-2023-32290-working-with-neo4j-with-djando-neomodel-library General Dara Silvera en My talk aims to provide a comprehensive overview of graph databases, going through the basics and fundamentals concepts. Graph databases are used for real-time transaction applications, Metadata and Advanced Analytics, Internal Business Process, and much more! There are plenty of use cases for graph databases such as recommendation systems, customer engagement, knowledge graph for AI, and so on. The best part is that you can visualize the data you store as nodes, and the queries you make as well, so it is easier to identify patterns and relationships within the data. This can help gain deeper insights into the data and make more informed decisions based on your findings. Also, the attendees will see how it can work with Django, using neomodel as an interface to communicate with Neo4j. Last but not least, we will dive into some of the graph algorithms, to take advantage of this kind of database and explore possibilities. This is an entry-level talk for people interested in databases. Basic database knowledge is recommended. We’ll cover: What is a graph database with Neo4j Possible use cases Differences between queries with Sql and Cypher language How to transform a relational database into a non-relational database A use case with Formula 1, using Django neomodel library, showing the graph data model, the graph that built and some interesting queries false https://pretalx.com/djangocon-us-2023/talk/TW3RXD/ https://pretalx.com/djangocon-us-2023/talk/TW3RXD/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-16T17:15:00-04:00 17:15 00:25 Learn how to benefit from powerful content-management features (such as: saving revisions, managing live/draft versions, moderating content, and more) for your Django models by integrating Wagtail CMS into your project. djangocon-us-2023-31933-modern-editing-experience-for-your-django-models-with-wagtail General Sage Abdullah en Can content management features be useful when managing arbitrary Django models? Wagtail is an open source, Django-powered Content Management System (CMS). It is built on the concept of pages as tree-structured Django models. As a CMS, Wagtail gives you the power to save revisions, manage live/draft versions, moderate your content, _live_ preview as you edit, and much more. A typical Wagtail project would have your user-facing website structure be defined by the tree structure of the Page model. However, if you have an existing Django project with your own defined Django views, and you don't want to use Wagtail's Page model, you can still get plenty of benefits from Wagtail! In this talk, we will learn how to benefit from powerful content-management features for your existing Django models by integrating Wagtail CMS into your project. This talk does not require any pre-existing knowledge about Wagtail CMS, though familiarity with Django models and external apps is expected. The talk will be structured as follows: - What Wagtail CMS is and how it compares with Django itself - Wagtail features likely relevant to many Django projects and how they work - How to integrate Wagtail into an existing Django project - How to progressively enable Wagtail's features and use them to manage your Django models false https://pretalx.com/djangocon-us-2023/talk/Y9QDGV/ https://pretalx.com/djangocon-us-2023/talk/Y9QDGV/feedback/ Online talks 25-minute talks 2023-10-16T10:40:00-04:00 10:40 00:25 Every week, in every city, hundreds if not thousands of decisions, big and small, are being made about the places where we all live. Most of the time, these decisions are hidden behind old systems, arcane websites, or poorly formatted PDFs. With the power of Datasette, Python data tooling, and Github actions, you can quickly set up a low-or-no-cost city data pipeline, and help us all better understand the decisions being made where we live. djangocon-us-2023-32091-automate-your-city-data-with-python General Philip James en It is very hard for the average resident of a U.S. or Canadian city to know what’s going on with their civic government. It’s even harder for them to get any sort of historical context on why things are the way they are. Let’s take my hometown, the City of Alameda. Six months ago if you wanted to know which city meetings had discussed rent control, your options were: - Have a friend who is a constant watcher of Alameda meetings / the #alamtg hashtag and could tell you - Go through every meeting minutes on the Alameda Legistar and hope you figured it out This is pretty common across a lot of civic government. I don’t think municipalities are willfully trying to hide this information from residents, and I don’t think it’s ineptitude. I think most cities, even the large ones, are understaffed, and without a concerted push it’s hard to make “visibility of city documents” a priority. What if we could have SQL-backed full text search of city meeting minutes? Well, thanks to Datasette, Python, AWS, and some Github actions, we can! Here's the process: 1. Figure out where official city minutes are hosted 2. Write a script to fetch and format those city minutes 3. Upload all the fetched minutes to AWS S3 4. Run s3-ocr across the corpus of minutes 5. Download the ocr’d pages into a sqlite DB 6. Deploy a datasette instance to fly.io with that sqlite DB. 7. Post to twitter so people know about it. In this talk, I will cover this whole process in detail, including how to automate it, so that you can apply this process to your city, county, state, school board, or any other civic government you're interested in! false https://pretalx.com/djangocon-us-2023/talk/WVRHG9/ https://pretalx.com/djangocon-us-2023/talk/WVRHG9/feedback/ Online talks 45-minute talks 2023-10-16T13:20:00-04:00 13:20 00:45 A survival guide for developers who may occasionally be called upon to perform the duties of a PostgreSQL DBA djangocon-us-2023-31400-how-to-ride-elephants-safely-working-with-postgresql-when-your-dba-is-not-around General Richard Yen en Every so often, one may be called upon to perform the tasks of a database administrator, especially in cases where application performance seems to be affected by the database. This talk will give non-DBAs an insight into how the world's most powerful open-source database works, and the kind of tools and features that are readily available for people who unexpectedly find themselves in the DBA pilot's seat. Topics covered will include query tuning, monitoring, indexing, and a basic run-down of some configurables to help you know what options are at your disposal false https://pretalx.com/djangocon-us-2023/talk/E3TR3L/ https://pretalx.com/djangocon-us-2023/talk/E3TR3L/feedback/ Online talks 25-minute talks 2023-10-16T15:25:00-04:00 15:25 00:25 Passkeys is a state-of-the-art technology that extends Web Authentication API allowing the user to use a key stored on a device to log in on a new device. The technology is supported by Apple, Google, and Microsoft and is available now on recent iOS/iPad, Andriod as well as Mac OS X Ventura. Passkeys allow the users to log in only through their private keys. It doesn't require the entry of a username and/or password, which provides a faster as well as safer environment for the users. Google released Passkeys for all users to log in with on May 3, 2023. The talk will discuss what is Passkeys and how it is more secure and phishing resistant, also it will show how to integrate them in your current Django project in a few lines of code. djangocon-us-2023-31842-passkeys-on-django General Mohamed ElKalioby en Web Authentication API (WebAuthn) is a phishing-proof technology that is expected to replace passwords. The technology is available since 2019, but in 2022, Apple, Google, and Microsoft agreed to support Passkeys, solving challenges facing the wide deployment of WebAuthn API. Passkeys is an extension to WebAuthn that allows the user to use a key credential stored in a device to log in on another device. e.g. you can use the key stored on your phone to log in on a browser on a Windows device. The communication is done over Bluetooth Low Energy (BLE). Passkeys are now supported on iOS/iPad 16, Mac OS X Ventura, and Andriod phones, and can be used by Chromium-based browsers and Safari. The talk will cover the following * what is WebAuthn and how it is phishing resistant even during a man-in-the-middle attack, * challenges in WebAuthn, * what are Passkeys and how they solved WebAuth challenges, * State of Passkeys, * Demo the usage of passkeys and their user experience. * How to integrate passkeys in your current Django project by `django-passkeys`. false django-passkeys https://pretalx.com/djangocon-us-2023/talk/889AWM/ https://pretalx.com/djangocon-us-2023/talk/889AWM/feedback/ Online talks 25-minute talks 2023-10-16T17:45:00-04:00 17:45 00:25 What started as a Website to show the schedule of a free radio, has resurfaced as the back-end of a radio automation software suite that provides the schedule through a REST API. djangocon-us-2023-32186-the-evolution-of-a-django-website-into-a-radio-automation-back-end General Ernesto Rico Schmidt en There are both commercial and open-source solutions for radio automation, but the requirements of free radios are very different from commercial radios, specially regarding the scheduling options and the end-user interface. With AURA, we are developing a free and open-source software automation suite for free radios. At the core of AURA is `steering`, a Django application that serves as the "source of truth" for the schedule and acts as an OpenID Connect provider for the components of the suite. First, I'll describe the situation free radios in Austria face: The commercial radio automation software available, and the only supposedly free solution, currently in use at some radio stations in Austria, has showed that a (Java) monolith and a single developer are not the best approach for the rather complex and varied schedule and play-out requirements of free radios. This moved a group of free radios in Austria to start the development of a free and open-source software suite of radio management, program scheduling and play-out automation software: AURA. Second, I'll give a short overview of the distributed architecture and the components of AURA, and focus on how it distinguishes from the monoliths that are currently in use at some of the free radios in Austria. Then, I'll explain the data models behind the Django application, with a special focus on the recurrence rules and the schedule conflict resolution, the most complex parts of `steering`. I will focus on the architecture decisions we took during the planing and development, and how the open-source development is a better and more sustainable approach to a common problem for free radio stations. I will show small snippets of code of the most interesting parts of the Django application, and explain the rationale behind them, specially the recurrence rules, and the schedule conflict resolution. In this case Django is not providing a Web application or a Web site but it is providing a REST API and acts as the back-end of a software suite, and serves as the "source of truth" for the scheduling and the play-out automation of the radio station. false https://pretalx.com/djangocon-us-2023/talk/ZCHYPR/ https://pretalx.com/djangocon-us-2023/talk/ZCHYPR/feedback/ Junior Ballroom 45-minute talks 2023-10-17T11:10:00-04:00 11:10 00:45 At some point, every application is limited by the database. You don’t have to be a Postgres expert to get started with a few key performance improvements. This gentle introduction is meant for folks who’ve never ventured into their database before, or those who have been turning knobs blindly. I’ll present how Postgres uses memory. Then, I’ll connect that to how you can monitor, tune, and optimize queries. You’ll be ready to take on the challenge as your application grows. djangocon-us-2023-32269-postgres-performance-from-slow-to-pro General Elizabeth Garrett Christensen en #### Review of how Postgres uses memory Measuring cache hit ratio Measuring memory usage and tuning Measuring shared buffer usage and tuning #### Connection settings Default connection settings, knowing when you need more #### Stop runwaywas Setting a statement timeout Finding and stopping transactions #### Query performance Using EXPLAIN Reading and understanding EXPLAIN plans Logging EXPLAIN plans Adding Indexes false https://pretalx.com/djangocon-us-2023/talk/CZSRUR/ https://pretalx.com/djangocon-us-2023/talk/CZSRUR/feedback/ Junior Ballroom 25-minute talks 2023-10-17T12:00:00-04:00 12:00 00:25 A case study of a single-application ETL system to scrape and enrich complex nested data and then expose it via GraphQL and Discord. It will dive into how to use these various async-based libraries together in a small footprint app. djangocon-us-2023-32165-swiss-army-django-small-footprint-etl General Noah Kantrowitz en ETL systems have become commonplace in our world, from tiny personal web scrapers to complex distributed data pipelines. With Django offering a fully async API, new possibilities have opened to simplify the many different microservices into a single Python application that hosts the scrapers, query systems, and administrative interface all in one box. With this comes simplified code and deployment, and many other benefits. This talk will cover a case study in building this kind of all-in-one ETL system, the components used, and how they all fit together. This includes both API and web scrapers, GraphQL for querying and streaming, and a Discord interface for notifications and control. false https://pretalx.com/djangocon-us-2023/talk/ZCHDJX/ https://pretalx.com/djangocon-us-2023/talk/ZCHDJX/feedback/ Junior Ballroom 45-minute talks 2023-10-17T14:05:00-04:00 14:05 00:45 Companies with vast data and complex processes must streamline their operations to ensure precision, scalability, and sustainability. In this talk about transitioning from Excel to Django, attendees will discover Django’s superpowers that enabled a national installer of battery energy storage solutions to optimize energy storage configurations, enhance accuracy, ensure reliability and improve quality assurance. Attendees will learn best practices and gain valuable insights for streamlining data-intensive processes and shaping a greener future. djangocon-us-2023-32284-django-unchained-powering-energy-storage-beyond-excel General Calvin Hendryx-Parker en In a world where renewable energy is crucial for combating climate change, a national installer of battery energy storage solutions found themselves outgrowing Excel and seeking a more powerful solution. Django’s superpowers allowed this company to optimize energy storage configurations, enhance accuracy in pricing models, and streamline business workflows. During this talk, we will discuss the process of converting complex Excel formulas into powerful Python code. Explore the cutting-edge technologies employed, such as Django's framework and a PostgreSQL database managed by AWS RDS. Discover how Docker and AWS App Runner facilitated seamless deployment, while the Next.js React front end transformed the user experience. The impact of this project extends far beyond a single company. Attendees will uncover best practices for empowering any organization, especially those with vast amounts of data and complex processes. Learn how to streamline operations, enhance accuracy, ensure reliability and improve quality assurance, all while embracing the power of Django. Discover how Django's superpower is driving innovation, efficiency, and impact in climate tech and beyond. Together, let's harness the power of Django and pave the way for a greener, more sustainable world. false https://pretalx.com/djangocon-us-2023/talk/APSBYK/ https://pretalx.com/djangocon-us-2023/talk/APSBYK/feedback/ Junior Ballroom 25-minute talks 2023-10-17T14:55:00-04:00 14:55 00:25 Are we really building products that serve everyone, or just a selected few? As developers, we have responsibility to ensure that our products serve everyone, regardless of their background or identity. However, our unconscious bias often creeps into even the most well-intentioned projects and impacts the way we develop products or engage with communities, leading to unintentional exclusions. When I first designed a Speech-Text-Analytic app, my focus was to simplify business communication with transcribed audio and valuable insights. However, feedback from the community highlighted it had limitations for diverse users, including those with disabilities who faced inaccurate captions for audio content. This wake-up call prompted me to improve accessibility and user-friendliness for marginalized groups. And for the same reason, I'm making proactive steps to cater for the marginalized by integrating a feature that recognizes Nigerian native languages. As tech creators, we have the power to create change, but good intentions alone are not enough. This talk will offer strategies to address unconscious bias in product and community building, while avoiding common pitfalls. Attendees will learn to understand diverse needs & experiences for more inclusive environments. djangocon-us-2023-31260-nothing-for-us-without-us-breaking-unconscious-bias-in-building-products General Victor Ogunjobi en In this talk, I'll share my experience developing a Speech-Text-Analytic app and the wake-up call when I realized it didn't serve our diverse user base, such as individuals with disabilities. This experience taught me the importance of considering the needs of all users, even those who may be marginalized or overlooked, and highlighted the impact of unconscious bias on well-intentioned projects. The talk will explore actionable strategies to recognize and mitigate unconscious bias in product development and community building, drawing from my personal experience. Attendees will learn how to better understand the needs and experiences of individuals from diverse backgrounds, resulting in more inclusive and supportive environments. My aim is to inspire and empower others to apply these approaches in their own projects and contribute to creating more inclusive communities. This talk is open to everyone (No background knowledge needed)! **Outline** I. Introduction **[3mins]** - Opening statement & Background - Importance of considering multiple identities in product development II. Unconscious Bias and Inclusive Product Development **[7mins]** - Impact of bias on development and engagement - Strategies to identify and address unconscious bias in tech - Demonstrating inclusive products, including a case study of an accessible Speech-Text-Analytic app III. Addressing Intersectionality **[5mins]** - Unique challenges faced by underrepresented groups in tech and how to address them - Role of open-source in promoting inclusivity; and project examples IV. Conclusion **[5mins]** - Recap of key points - Key takeaway message for the audience: Strategies, Results & Lessons - Future directions of tech for promoting sustainability and inclusivity V. Q & A Session **[5mins]** false https://pretalx.com/djangocon-us-2023/talk/MUNZTT/ https://pretalx.com/djangocon-us-2023/talk/MUNZTT/feedback/ Junior Ballroom 25-minute talks 2023-10-17T15:55:00-04:00 15:55 00:25 The djangoproject.com website is the showcase of the Django project and is the result of contributions from many people. In this talk, we'll update you on its development and learn how to contribute to it. djangocon-us-2023-32117-all-about-djangoproject-com General Paolo Melchiorre en The djangoproject.com website is the showcase of the Django project and developers and users have always looked for updates on the project, documentation, and information from the Django Software Foundation. As with its source code, the Django project site is also the result of contributions from many people who voluntarily help to keep it updated and improve it. In this talk, we will see all the latest updates, ongoing improvements, and upcoming developments of the Django project site. Participants will be able to learn more about the Django project site, learn more about how it is maintained and above all understand how to help improve it. false https://pretalx.com/djangocon-us-2023/talk/JLR7UA/ https://pretalx.com/djangocon-us-2023/talk/JLR7UA/feedback/ Junior Ballroom 45-minute talks 2023-10-17T16:25:00-04:00 16:25 00:45 As creators of software, we're repeatedly told that we're not merely imagining the future of the world, but bringing it into being. Let's suppose that's true. What, exactly, are we imagining? djangocon-us-2023-28722-the-programmer-s-imagination General Daniele Procida en Of all our faculties, imagination is usually considered the freest, the seat of creation. I'm interested in what we are doing with this freedom, and I am suspicious of it. I want to pay attention to the programmer's imagination, and show how the imagination draws lines between things as disparate as Django's success page for new projects and what we think dinosaurs look like. As programmers, our imagination conjures up new worlds on blank pages, but I think that imagination can always be traced back to assumptions, prejudices and desires that are active right now - the programmer's imagination isn't telling us about the future, but about *now* - and what's wrong with it. I want to show what the imagination has meant for what we do with the software we create, and what it means for the future. I will use it to identify some of the things we have lost in the last decades, and how we can find them again. What do small and harmless things like Django's own success page tell us about our own thinking? *What does Django make us think?* I will probe questions like this, and other things: dinosaurs and birds, palaeoart and 1980s computer programming books, David H Ahl and Joseph Weizenbaum. I want to help make sense of what we're doing, what we think we're doing, the relationship between them - and what, perhaps, we *should* be doing. false https://pretalx.com/djangocon-us-2023/talk/DMVEUV/ https://pretalx.com/djangocon-us-2023/talk/DMVEUV/feedback/ Junior Ballroom 25-minute talks 2023-10-17T17:15:00-04:00 17:15 00:25 Multitenancy is a broad spectrum, ranging from using separate databases for each tenant to using a shared database and schema. This talk will present a “lightweight” multitenancy use case that we’ve run into across different projects in various contexts. We will present a simple custom solution using Django Rest Framework and explain why it worked for our needs. We will also go over which cases could use a similar approach (and which could not), as well as a different approach using an existing library. djangocon-us-2023-32288-an-approach-to-lightweight-tenancy-management-using-django-rest-framework General Eliana Rosselli en Over the last few years, I have run into the same multitenancy use case across different projects. This scenario is a “lightweight” multitenancy use case, where we have a tenant model and tenants are instances of this model; all tenants share the same database, schema, and application instance. Resources belong to a single tenant, but users can belong to multiple tenants. Almost all api routes need to be nested under the tenant id, with urls of the form `api/tenants/tenant-id/some-resource`. The challenges we faced were how to effectively nest our API urls and how to consistently restrict access to resources, so that users could only access those resources that belong to tenants that the user has permission to access. We’ll cover: - A brief description of the use case, multi-tenancy and object-level permissions - How we implemented nested routes in our API using [drf-nested-routers](https://github.com/alanjds/drf-nested-routers) - How we wrote a custom viewset to centralize all logic related to checking that the user has permission to access resources under a specific tenant - Custom model manager to avoid accidentally leaking information from other tenants - Uses and limitations of our approach - A different approach using an existing library ([drf-access-policy](https://github.com/rsinger86/drf-access-policy)) Anyone with experience in Django is welcome! false https://pretalx.com/djangocon-us-2023/talk/YANNZE/ https://pretalx.com/djangocon-us-2023/talk/YANNZE/feedback/ Grand Ballroom II-III 45-minute talks 2023-10-17T11:10:00-04:00 11:10 00:45 GraphQL has gained popularity for its ability to offer more flexibility and performance over traditional REST APIs. Strawberry is a new and fast-growing GraphQL library for Python, inspired by dataclasses functionality, that offers a modern and intuitive API for building GraphQL APIs using type hints. In this talk, we will explore the basics of building a GraphQL API with Strawberry and how it can be integrated with Django in a performant and type-safe way, by generating its types and resolvers directly from Django models. We will also compare and contrast the benefits and drawbacks of GraphQL versus REST APIs, including how GraphQL can help improve frontend development workflows. Attendees will come away with an understanding of how Strawberry can help simplify the process of building and maintaining GraphQL APIs, and how to use its powerful features to optimize for performance, safety, and flexibility, while also covering its drawbacks and how to avoid some common issues. djangocon-us-2023-32265-building-high-performance-type-safe-graphql-apis-with-strawberry-and-django General Thiago Bellini Ribeiro en In this talk, we will explore the world of GraphQL APIs with Strawberry, a new Python library that makes it easy to create GraphQL APIs with Django. We will dive into what GraphQL is, how it compares to traditional RESTful APIs, and what makes Strawberry stand out from other Python GraphQL libraries. One of the biggest challenges in GraphQL API development is the N+1 problem, where queries can become exponentially slow as more data is requested. We will discuss how data loaders can help solve this problem, and go in-depth on how to use them in Strawberry. In this topic we will also cover some extensions that leverage query introspection and user defined hints to automatically call .only()/.select_related()/..prefetch_related() on querysets, making your queries more efficient and avoiding common pitfalls. This is especially important in high-traffic, production environments where performance is critical. Finally, we will showcase some of the benefits of using Strawberry and Django together, including a type-safe approach to API development and streamlined code maintenance. By the end of this talk, you'll have the knowledge and tools you need to create high-performance GraphQL APIs with Strawberry and Django. It will be presented in the following order: - Intro - What is GraphQL and how it compares to other approaches, like REST - Writing general GraphQL APIs using Strawberry - Integrating the Django ORM with Strawberry - Some common pitfalls, with emphasis on the N+1 problem - GraphQL tools to avoid those pitfalls and how to use them with Strawberry - How some libs uses introspection to automatically overcome those pitfalls and also improve performance when executing Django querysets false https://pretalx.com/djangocon-us-2023/talk/W8CKND/ https://pretalx.com/djangocon-us-2023/talk/W8CKND/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-17T12:00:00-04:00 12:00 00:25 Have you ever encountered a codebase where modifying code seemed impossible due to the constraints of the test suite? Are the tests that you write today inadvertently restricting future improvements? In this talk, we will uncover how placing empathy at the forefront of test suite development can empower rather than hinder future developers, including your future self. djangocon-us-2023-32187-empathetic-testing-developing-with-compassion-and-humility General Marc Gibbons en Tests can be a powerful tool used to increase our development speed and empower us with the confidence to refactor and improve codebases. Writing tests with these goals in mind requires empathy and compassion toward other developers and even our future selves. Conversely, tests written with different objectives, such as achieving an arbitrary coverage score, can have the opposite effect and cause suffering. Together, we will explore the following ideas: - How writing tests beforehand is an act of compassion. - Testing outcomes, rather than implementation choices, takes humility. - Empathizing with cognitive overwhelm: how isolating and minimizing test setup can make your code easier to understand and extend. - Do you really need that mock? Balancing the needs of now with those of the future. This talk aims to provide valuable insights for beginners embarking on their testing journeys and challenge experienced developers to contemplate their philosophy toward testing. While a basic familiarity with testing in Django is beneficial for understanding practical examples, it is not a prerequisite. false https://pretalx.com/djangocon-us-2023/talk/T9ZZ7H/ https://pretalx.com/djangocon-us-2023/talk/T9ZZ7H/feedback/ Grand Ballroom II-III 45-minute talks 2023-10-17T14:05:00-04:00 14:05 00:45 Learn about GitHub Actions, a CI/CD platform for automating build, test, and deployment pipelines. This presentation provides an overview of key terms and concepts, as well as a step-by-step guide to creating reusable components known as "Actions". Perfect for developers new to automation or those looking to transition to GitHub Actions. djangocon-us-2023-29309-introduction-to-github-actions-understanding-key-terms-and-building-your-first-github-action General PAUL GILZOW en We all know we should be doing more automation of our software development lifecycle, but getting started can be challenging. Even if you have experience in continuous integration and continuous delivery (CI/CD) automation, learning a specific platform's terminology and idiosyncrasies can be frustrating. This presentation is designed to provide an overview of GitHub Actions, a CI/CD platform that allows you to automate your build, test, and deployment pipelines, and writing one's first Action, a reusable component that can automate repeatable tasks. We'll start by going over key terms and concepts in the GitHub Actions platform, such as actions, workflows, events, and jobs, and explain how they can be pieced together to build robust and dynamic automations. Then, we'll dive into the process of building your first GitHub Action, walking through the steps of creating a new action, the types of actions you can create, defining inputs and outputs, and required properties. We'll then work together to build an action that can be immediately used in your own workflows. Whether you're a seasoned developer looking to move to GitHub Actions, or a newcomer to automation looking to get started with your first CI/CD automation this presentation will help jumpstart your journey. false https://pretalx.com/djangocon-us-2023/talk/TVVB8Q/ https://pretalx.com/djangocon-us-2023/talk/TVVB8Q/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-17T14:55:00-04:00 14:55 00:25 Django is a popular web framework that comes with a powerful database migration system. However, managing database schema changes can be a challenging task, especially in complex projects with multiple developers and frequent releases. Conflicts can arise when multiple developers modify the same models or when migration files are applied in the wrong order. Rollbacks are also necessary when migrations fail or need to be reverted. We will explore different strategies for handling conflicts and rollbacks in Django database migrations, discuss how to prevent conflicts by using tools such as database locking, how to resolve conflicts manually and how to use migration squashing to reduce the number of migration files. Additionally, we will explain how to handle rollbacks by using version control systems and backups. By attending this talk, attendees will gain a deeper understanding of the challenges involved in managing database migrations in Django and learn practical strategies for handling conflicts and rollbacks. They will be able to apply these strategies in their own projects to improve their development workflow and ensure data integrity. djangocon-us-2023-31913-strategies-for-handling-conflicts-and-rollbacks-in-django-database-migrations General Abigail Afi Gbadago en Managing database migrations in Django can be challenging, especially in large projects with multiple developers and frequent releases. Conflicts can arise when multiple developers modify the same models when migration files are applied in the wrong order or in some cases where fields are faked. Rollbacks are also necessary when migrations fail or need to be reverted. This talk will explore various strategies for handling conflicts and rollbacks in Django database migrations. The aim is to provide attendees with practical solutions that can help them effectively manage database schema changes in their Django projects. Some of the strategies that will be discussed in the talk include using database locking to prevent conflicts, resolving conflicts manually by merging migration files, using migration squashing to reduce the number of migration files, and handling rollbacks by using version control systems. Attendees will learn how to identify and resolve conflicts in their migration files and how to apply best practices to ensure a smooth migration process. They will also gain insights into how to minimize the risk of data loss and downtime during rollbacks. By the end of the talk, attendees will have a deeper understanding of the challenges involved in managing database migrations and be better equipped to handle conflicts and rollbacks in their Django projects. false https://pretalx.com/djangocon-us-2023/talk/VGGNMN/ https://pretalx.com/djangocon-us-2023/talk/VGGNMN/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-17T15:55:00-04:00 15:55 00:25 Have you ever felt that unit tests just weren’t enough? It just feels like there’s always something wrong when your customers start to use your application. All your unit tests pass, so where does the problem stem from? It turns out we need to start thinking like *users*, not *developers* . In this talk, you'll get a look at the the `behave` library to explore executable specifications and behavior driven development. You'll learn effective practices around specification testing and how to integrate that into your workflow. You'll also learn how to drive automated testing of a Django App through the web browser, via the _selenium_ library. djangocon-us-2023-31885-bdd-to-the-bone-acceptance-testing-with-behave-and-selenium General Pat Viafore en It's easy to get caught up in testing metrics. We all do it. We aim for 100% code coverage, try to hit all branches, write good integration tests, and all the other good developer practices. These all indicate that we are building our product right, but are we building the right product? There's a different mentality when it comes to answering this question. We, as developers, can't just make sure that the code does what *we* want it to do. We need to think about what our users want. We need good requirements and specifications and we need to make sure that we are covering user acceptance testing. In this talk, we're going to discuss why requirements are hard to get right, and how we can solve some of those problems. We'll introduce strong traceabilty with executable specifications and then talk about how to tie that directly to your Python tests. We'll discuss behavior driven development, primarily with the `behave` library. After we cover the basics, we'll look at a Django application and talk about the challenges in performing user acceptance testing on websites. We'll use the `selenium` library to drive website interactions through Python, and tie it all together with acceptance tests. This talk assumes basic knowledge of testing practices, Python, and HTML/JavaScript. false https://pretalx.com/djangocon-us-2023/talk/X8DRQN/ https://pretalx.com/djangocon-us-2023/talk/X8DRQN/feedback/ Grand Ballroom II-III 45-minute talks 2023-10-17T16:25:00-04:00 16:25 00:45 Explore options for building Django-based content-managed websites that editors will love. Learn about the features and patterns necessary for content editing and how they are supported in Django-land. Gain the knowledge to select the best Django-driven CMS for their next project. djangocon-us-2023-32309-managing-content-with-django General Michael Trythall en Django is used to power lots of high-traffic, content-driven websites. It’s a great fit, providing features that help quickly scaffold data-rich systems with slick editing. But the admin isn’t powerful enough to make managing rich content super user-friendly. Luckily, Djangonauts have some solid solutions for building excellent content-managed websites. This talk explores Wagtail, django CMS, and other options and helps developers pick the right tool for their next project. false https://pretalx.com/djangocon-us-2023/talk/SLFJKB/ https://pretalx.com/djangocon-us-2023/talk/SLFJKB/feedback/ Grand Ballroom II-III 25-minute talks 2023-10-17T17:15:00-04:00 17:15 00:25 Beginners often stumble when it’s finally time to get their Django app online. Instead of another deployment recipe, this talk seeks to explain the fundamental concepts of deploying a Django app and equip developers to think through the process for themselves when they’re ready to make the transition from their code editor to the web. djangocon-us-2023-31644-what-django-deployment-is-really-about General James Walters en People often spend so much time learning how to build apps in Django that when it comes time for deployment, it feels like a whole new world that they don't understand. Deployment recipes might help them get their app online--but then again they might not, if the steps that worked yesterday don't work today. Even if they do get online, they might not understand that deployment process anymore than they did before. Instead of offering another set of steps, I think we can help beginners to make sense of deployment by reducing the entire process to four major areas of concern and equipping them to think through each of these on its own terms: 1. Static Files - why do I have to worry about these now? I thought `{% raw %}{% static %}{% endraw %}` was handling it? 2. Database - does my sqlite3 file not work in deployment? How do I use my cloud provider's remote DB? 3. WSGI Server - how do I run my app in production? Doesn't manage.py runserver work? I've never heard of WSGI, what is it and why does it matter to my Django project? 4. Web Server (Apache/nginx/PaaS) - What do I need to understand about web servers like Apache or nginx to get my project online? Do I even need to configure a web server if I go with PaaS? Minor concerns we'll also consider: - Getting your code into the deployment environment - Managing Secrets - Django's deployment checklist - django-simple-deploy A link to slides will be posted after the talk at http://james.walters.click/ false https://pretalx.com/djangocon-us-2023/talk/PAYTYZ/ https://pretalx.com/djangocon-us-2023/talk/PAYTYZ/feedback/ Online talks 25-minute talks 2023-10-17T10:40:00-04:00 10:40 00:25 As the most popular and mature solution for asynchronous task queues in Python’s ecosystem, Celery is an essential tool for Django projects. But running Celery tasks with high reliability is a challenge. The settings are tricky, tasks can be lost in multiple ways, task code has opaque limitations, proper monitoring isn’t trivial, and more. In this talk, we’ll share what we learned to be necessary for running Celery reliably after years of running it in production. djangocon-us-2023-31835-mixing-reliability-with-celery-for-delicious-async-tasks General Flávio Juvenal en Celery is essential for asynchronous processing in Django backends. In multiple Django projects, we used far beyond the use case of sending emails without blocking HTTP responses. Celery helped us aggregate data, fill caches, run ETL workflows, parallelize heavy workloads, sync with external services, set up periodic background jobs, and much more. But as with any distributed system, running Celery reliably in production is challenging. Due to the many issues we’ve seen on Celery, we considered many times replacing it with other task queues. But we never found another library with the features Celery offers. So we had to learn to work around its shortcomings and pitfalls. After years of running it in multiple Django projects, we faced and solved several reliability problems. We remediated concurrency hazards. We dealt with lost tasks in multiple edges of the architecture. We read tons of docs, articles, and issues to properly tweak settings. We fixed weird serialization bugs after version upgrades. We found what kind of monitoring really needed. In this talk, you will learn how to configure, use and monitor Celery successfully in production. Celery performs well in simple contexts, because of that it might induce a false sense of safety that can be misleading as usage picks up and flows become more complex. Understanding the many ways it can fail as projects grow will help developers to prepare in advance. Outline: - [2 minutes] Common concurrency issues - [5 minutes] Recommended settings - What Broker and Result Backend to use - What happens when using others - Serialization: pickle or not? - Thresholds and limits - Timeouts and expires - [5 minutes] How tasks can be lost and how Celery (tries) to solve that - ACKS_LATE, idempotency, and retries - Why that task again? Visibility timeout, prefetches, and automatic redelivering - Dead worker process, lost task - You need atomicity too - [5 minutes] Don’t use Celery canvas workflows: you need DB-level state - [2 minutes] Multiple queues and workers will save you from complex incidents - [2 minutes] The only monitoring you can trust: probe tasks - [2 minutes] Graceful shutdowns: Celery and Continuous Deployment - [3 minutes] Questions false https://pretalx.com/djangocon-us-2023/talk/W9W8CL/ https://pretalx.com/djangocon-us-2023/talk/W9W8CL/feedback/ Online talks 45-minute talks 2023-10-17T13:20:00-04:00 13:20 00:45 Are you grappling with a project morphing into a 'Big Ball of Mud'? Are you conversant with Domain-Driven Design (DDD) but unsure about its application to Django projects? This talk will navigate you through three levels of implementing DDD in Django projects right from the ground up. Expect to walk away with the knowledge of transforming your Django project by employing DDD techniques at various levels based on your project's needs and constraints. djangocon-us-2023-32173-decoding-ddd-a-three-tiered-approach-to-django-projects General Pavel Sviridov en ## Audience This talk is geared towards intermediate to advanced Django developers who want to improve the structure and maintainability of their projects. ## Description Every project has its unique history and limitations. In this session, I will navigate you through three levels of implementing DDD in Django, from basic to advanced. You will understand how to apply DDD to your Django project strategically and tactically and learn how to balance the costs and benefits of each level. **Level 0: Ubiquitous Language and Bounded Contexts** We'll begin with an easy-to-implement approach, focusing on strategic DDD patterns. Then, we'll delve into creating Ubiquitous Language and discovering Bounded Contexts through Event Storming sessions - an engaging technique to visualize and define domains collaboratively. **Level 1: DDD tactical patterns** We'll move on to tactical patterns like entity, aggregate, repository, and domain services. Here, you'll understand how the standard usage of Django models may lead to a lack of integrity and how DDD patterns can provide business-level integrity. **Level 2: Advanced DDD** Finally, we'll explore advanced DDD techniques. We'll cover how to design a domain layer in pure Python independent of the framework and why this approach can lead to cleaner, more testable code. ## Takeaways By the end of this talk, you will have: 1. A clear understanding of implementing DDD in Django projects at different levels based on your requirements. 2. A solid grasp of the strategic and tactical patterns in DDD and how they can improve your Django project. 3. Hands-on experience in creating Ubiquitous Language and discovering Bounded Contexts through Event Storming sessions. 4. Knowledge of how to ensure business-level integrity in your project using DDD tactical patterns. 5. Insights on how to write a domain layer in pure Python, independent of the framework, and how it can lead to cleaner, more testable code. ## Engagement In this session, I will focus on linking theory with practical examples. Drawing from my experience refactoring a 5-year-old Django monolith, which continues to be actively developed by five different teams, I have many real-world examples to illustrate different approaches. These examples are particularly insightful as they are based on diverse DDD approaches tried in various parts of the project and incorporate feedback from developers and business experts. false https://pretalx.com/djangocon-us-2023/talk/F7KFUB/ https://pretalx.com/djangocon-us-2023/talk/F7KFUB/feedback/ Online talks 25-minute talks 2023-10-17T15:25:00-04:00 15:25 00:25 Interested in trying out OSS contributing, and can't find a project you're comfortable in? Maybe you found an issue but the scope is too big to start? There are other ways to get into OSS! In this chat, we'll cover non-code contributions, the different types there is, and how to get started in a way that works for you. djangocon-us-2023-32261-there-s-more-to-open-source-than-code General Ramón Huidobro en Open source software has always been about more than just code. While the technical contributions of developers are critical to the success of an open source project, there are countless other ways that people can contribute to the community. From documentation and translation to community management and design, non-code contributions are essential to building a healthy and sustainable open source ecosystem. In this talk, we will explore the many different ways that people can contribute to open source beyond writing code. We'll discuss the importance of diverse perspectives and skill sets in creating a thriving open source community, and provide examples of successful projects that have leveraged non-code contributions to achieve their goals. We'll also offer practical tips and advice for those interested in getting involved in open source but who may not have coding experience. By the end of this talk, attendees will have a deeper understanding of the many ways that they can contribute to open source, and how their unique skills and talents can help to build a stronger and more inclusive community. They will leave with a renewed sense of excitement and motivation to get involved in open source, regardless of their technical background. false https://pretalx.com/djangocon-us-2023/talk/UD7BCZ/ https://pretalx.com/djangocon-us-2023/talk/UD7BCZ/feedback/ Junior Ballroom 25-minute talks 2023-10-18T12:00:00-04:00 12:00 00:25 Data visualization is an essential component of data science, and web-based data visualization is becoming increasingly popular. In this talk, we will explore how to integrate Django, a popular Python web framework, with two of the most popular data visualization libraries, D3.js and Bokeh, to create interactive and dynamic visualizations for your data science projects. djangocon-us-2023-31873-django-s-data-science-makeover-integrating-d3-js-and-bokeh-for-data-visualization Deep Dive Drishti Jain en Django is a versatile web framework that can be used for building a wide range of applications, from blogs to e-commerce platforms. In recent years, there has been a growing demand for web-based data visualization, which requires integrating data visualization libraries with web frameworks like Django. This talk will demonstrate how to use D3.js and Bokeh, two popular data visualization libraries, with Django to create dynamic and interactive visualizations. We will start by discussing the basics of Django and data visualization with D3.js and Bokeh. We will then dive into the specifics of integrating these libraries with Django. You will learn how to leverage Django's powerful database and ORM to feed data to your visualizations, and how to customize your visualizations with CSS and JavaScript. We will also cover some advanced topics, such as real-time data streaming with Django Channels and integrating machine learning models with your visualizations. By the end of this talk, you will have a solid understanding of how to integrate D3.js and Bokeh with Django for your data science projects. You will leave with the skills needed to create stunning and interactive visualizations that can be embedded in your Django web applications. false https://pretalx.com/djangocon-us-2023/talk/FBPPPL/ https://pretalx.com/djangocon-us-2023/talk/FBPPPL/feedback/ Junior Ballroom 45-minute talks 2023-10-18T14:05:00-04:00 14:05 00:45 By an order of magnitude, Celery remains one of the most popular Django-adjacent packages for Python. In this talk, I'll explore what continues to make Celery a go-to solution for background and scheduled jobs with Django, how to integrate Celery with a Django project, and some common patterns to use (and avoid!) when writing tasks with Celery. djangocon-us-2023-32319-how-to-schedule-tasks-with-celery-and-django Deep Dive Tobias McNulty en Celery is a distributed system for message processing in Python first released in 2009, not long after Django itself. With over 20,000 stars on GitHub, it remains one of the most popular Django-adjacent Python packages. Similarly, my colleague Dan's post on the Caktus blog, "How to Use Celery for Scheduling Tasks," is by an order of magnitude one of the most popular pieces of content on our site. In this talk, I'll explore what continues to make Celery a popular choice for message processing and background jobs, including: - The fundamentals of integrating Celery with a Django project - What is a message broker and how to choose one - What is a result backend and how to choose one - How to run tasks on pre-defined schedules, via settings and/or the database - How to break apart long-running tasks to maximize scalability - Other common patterns and anti-patterns when writing tasks with Celery false https://pretalx.com/djangocon-us-2023/talk/BEL9ZP/ https://pretalx.com/djangocon-us-2023/talk/BEL9ZP/feedback/ Junior Ballroom 25-minute talks 2023-10-18T14:55:00-04:00 14:55 00:25 Proxy models are part of Django’s inheritance styles, but how to they work, how are they different from other inheritance styles that Django provide, practically where can they be applied in real world scenarios. Using simple code snippets and practical examples lets explore proxy models. djangocon-us-2023-29086-one-database-table-one-model-many-behaviours-proxy-model Deep Dive Ron Maravanyika en At times, when inheriting a model one doesn’t want to create a table in the database, you maybe looking to change just the pythonic behaviour of the data without necessarily creating a new table, for example you might be looking to ordering the data while maintain the original model data structure, this is where Django proxy models come in play, this talk will highlight, what are proxy models, how they are created using the model’s Meta class and how they can make your life easier as a developer. Furthermore, confusion around which restrictions are imposed on base class by Django when using proxy models will be brought to rest during this talk. The possibilities of proxy models inheriting multiple abstract models will be covered in this talk. Proxy mode manipulation of the Model manager and when to manipulate the Manager will also be part of the talk’s package. Being fairly similar to unmanaged models, the talk will highlight the most common differences and when to use each of them. Reading through the Django proxy model, or even reading through the first paragraph above makes one say “cool stuff !!!” and then the next thing you forget about it. This is because finding the practical application of proxy models in real world scenarios is difficult. This talk will showcase practical aspects of using proxy model through the use on an abstract base class, equipping developers mind with an image or the possibilities of this proxy model. false https://pretalx.com/djangocon-us-2023/talk/3CY3LN/ https://pretalx.com/djangocon-us-2023/talk/3CY3LN/feedback/ Junior Ballroom 45-minute talks 2023-10-18T16:00:00-04:00 16:00 00:45 Ever wonder how accessible Django is? Sites built with Django, the admin, the docs. Let’s find out! We will leverage the HTTP Archive’s websites technology dataset to quantitatively review common accessibility issues on Django projects – and then we’ll dive into Django’s implementation choices to understand the results. djangocon-us-2023-31184-django-s-accessibility-track-record Deep Dive Thibaud Colas en There are great accessibility guidelines out there. Great tools to evaluate individual websites too. Between the big picture and individual projects, we can look at what Django specifically does – and what changes at the level of the framework could improve large swaths of the Django web. We will start by looking at the HTTP Archive’s dataset of 8M websites, 30’000 of which are built with Django. We can identify which issues are common compared to other frameworks, and review specific issues in more depth to understand where they might appear in Django. We can then look into the implementation details to understand exactly how users of assistive technology would benefit or be harmed by Django’s design choices. And accordingly highlight the correct approach. A practical example of this where we can go very deep is Django’s implementation of HTML forms. Django’s default markup previously left a lot to be desired, and it being “the default” led to a lot of websites shipping with accessibility issues. This has been improved from release to release, addressing basic issues and introducing more advanced patterns like ARIA attributes for errors. false https://pretalx.com/djangocon-us-2023/talk/AWMNED/ https://pretalx.com/djangocon-us-2023/talk/AWMNED/feedback/ Online talks 25-minute talks 2023-10-18T10:40:00-04:00 10:40 00:25 Django migrations are a great tool, but after years of changes in a project they can become very numerous, slowing down tests. Is it possible to optimize them? djangocon-us-2023-30597-django-migrations-friend-or-foe-optimize-your-django-migrations-for-faster-testing Deep Dive Denny Biasiolli en Django migrations are a great tool for keeping track of changes you made to your models over time. After years of changes in a project they can become very numerous and you may notice that it takes a long time to create the test database. `squashmigrations` can help you reduce an existing set of many migrations down to one (or sometimes a few), which still represent the same changes. However it has some limitations, and it could work in a way you don't need. Let's inspect this command and the alternative of creating migrations "from scratch" in an existing project for improving your tests speed. - inspecting django migration commands - `makemigrations` - `migrate` - `showmigrations` - `sqlmigrate` - creating a sample project with multiple migrations - analyzing test performances - inspecting the `squashmigrations` command - squashing migrations in the sample project and comparing performances - not enough? Let's try an "exotic/drastic" way to squash our migrations - comparing performances of the "exotic/drastic" solution The key point of this talk is to speed up django testing in projects with many migrations false https://pretalx.com/djangocon-us-2023/talk/ZVHHDV/ https://pretalx.com/djangocon-us-2023/talk/ZVHHDV/feedback/ Online talks 45-minute talks 2023-10-18T13:20:00-04:00 13:20 00:45 Wagtail is one of the most popular content management systems in the Django world, and the Wagtail team is committed to making it as easy as possible to create accessible websites. It still requires intention and effort on the part of a developer creating a Wagtail website, though. Learn the tools and techniques you need to set your editors up for success. djangocon-us-2023-32303-best-practices-for-making-a-wagtail-site-as-accessible-as-possible Deep Dive Scott Cranfill en Over the past few years, the Wagtail CMS core team and accessibility subteam have made [significant commitments to improving Wagtail's accessibility](https://wagtail.org/accessibility/) – both the CMS interface itself as well as the websites that it produces. This talk is focused on the latter, aiming to show how you (a developer of a Wagtail-powered site) can set up your models, templates, and workflows in order to make it as easy as possible for your editors to create websites that are as accessible _as possible_. I say "as possible" because it's important to recognize that it's virtually impossible for a website to ever be considered 100% accessible, but with some care put into what we do on the development side, we can prevent some of the most widespread accessibility issues that users may come across. Some of the topics that are planned to be covered include: - How to configure and use Wagtail's [new built-in accessibility checker](https://wagtail.org/blog/introducing-wagtails-new-accessibility-checker/) - Ensuring alt text is used appropriately (Spoiler alert: every image doesn't need alt text!) - Usage of `aria-label` attributes to provide essential context to screen readers - Custom validation to ensure that a page has a logical heading order false https://pretalx.com/djangocon-us-2023/talk/RNQYRP/ https://pretalx.com/djangocon-us-2023/talk/RNQYRP/feedback/ Online talks 25-minute talks 2023-10-18T15:25:00-04:00 15:25 00:25 Django is leading the charge when it comes to hypermedia adoption in the Python space. Let's take a look at patterns, tools, and projects that leverage htmx, examining where we are and where we are going in this ecosystem. djangocon-us-2023-32083-back-to-the-future-of-hypermedia-in-django General Mario Munoz en "Hypermedia is your friend", they said. "You don't need JavaScript", they said. "You'll be _fine_..." It's no secret that hypermedia has been making a quiet resurgence in the web development landscape. One of the most popular toolkits in the Python space is htmx, offering a simple, declarative approach to AJAX and Server Sent Events directly from your HTML. While this trend is taking shape in the Python ecosystem as a whole, Django goes even further, providing a maturing set of patterns, tooling, and projects that take full advantage of these new (old?) paradigms. What are some of the ways that Django is leading the charge in making hypertext cool again? What are some examples of projects already utilizing these tools? Is this a viable approach to _serious_ web design? And what are some of the ways that we could improve the adoption of hypermedia within Django, and Python as a whole? false https://pretalx.com/djangocon-us-2023/talk/LB7G9P/ https://pretalx.com/djangocon-us-2023/talk/LB7G9P/feedback/